4.26 score from hupso.pl for:
beingjavaguys.com



HTML Content


Titlejava, struts 2, spring, hibernate, solr, mahout and hadoop tutorials tips and tricks

Length: 84, Words: 12
Description a blog about java technologies core java, struts2, spring mvc, hibernate, solr, mahout and hadoop tutorials with hello world applications in eclipse.

Length: 149, Words: 22
Keywords java struts2 spring and hibernate tutorial,servlet and jsp tutorial, what is bigdata, analysis of big data,xp3pojd4_3dnctm_2ersnvxniyq
Robots
Charset UTF-8
Og Meta - Title exist
Og Meta - Description exist
Og Meta - Site name pusty
Tytuł powinien zawierać pomiędzy 10 a 70 znaków (ze spacjami), a mniej niż 12 słów w długości.
Meta opis powinien zawierać pomiędzy 50 a 160 znaków (łącznie ze spacjami), a mniej niż 24 słów w długości.
Kodowanie znaków powinny być określone , UTF-8 jest chyba najlepszy zestaw znaków, aby przejść z powodu UTF-8 jest bardziej międzynarodowy kodowaniem.
Otwarte obiekty wykresu powinny być obecne w stronie internetowej (więcej informacji na temat protokołu OpenGraph: http://ogp.me/)

SEO Content

Words/Characters 12551
Text/HTML 42.58 %
Headings H1 0
H2 50
H3 10
H4 0
H5 0
H6 0
H1
H2
java and j2ee tutorials, jsp and servlet tutorials, spring mvc, solr, xml, json examples, hibernate & struts 2 hello world projects
saturday, 27 february 2016
java 8 lambda expressions (functional interfaces, variable capture, method references, default methods)
java 8 lambda expressions
java 8 lambda concept
java 8 lambda syntax
java 8 lambda functional interfaces
java 8 lambda variable capture
lambda are not anonymous inner classes
java 8 lambda method references
java 8 default methods in interfaces
saturday, 20 february 2016
java programming - introduction
what is java ?
properties of java
java tools
saturday, 15 november 2014
how first level caching works in hibernate - example
caching in hibernate
first level caching in hibernate
how first level caching works in hibernate
how evict() and clear() works in hibernate
download how first level caching works in hibernate project
saturday, 18 october 2014
securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest)
integrating spring security with oauth2 to secure restful web services.
dependencies required to integrate spring mvc , spring security and oauth2
spring security oauth configuration
spring configuration file
deployment descriptor
domain classes
get spring security and oauth2 integration source code from git hub
sunday, 31 august 2014
spring security with hibernate using maven - authentication and authorization example
database setup for spring security and hibernate integration
dependencies required for spring security with hibernate integration
spring security configuration file
login controller code
model classes to represent "user" and "user_role" tables in database
data layer for spring security and hibernate configuration
front end layer files
how to run the application
download "spring security with hibernate example project" from "skydrive"
thursday, 14 august 2014
spring 4 restful web services with hibernate 4 example using maven – server application
dependencies required to make spring restful web services with hibernate
model classes
data layer with spring and hibernate
download "spring 4 restful web services with hibernate 4 example" from "skydrive"
contact
H3
spring security authentication and authorization example with database credentials
spring 4 restful web services with hibernate 4
spring security with hibernate using maven - authentication and authorization example
spring mvc - json response with @responsebody annotation (spring + json)
integrate neo4j (graph db) with java – neo4j with java (neo4j + java)
spring security authentication and authorization example with database credentials
spring 4 restful web services with hibernate 4
spring security with hibernate using maven - authentication and authorization example
spring mvc - json response with @responsebody annotation (spring + json)
integrate neo4j (graph db) with java – neo4j with java (neo4j + java)
H4
H5
H6
strong
b
i
em
Bolds strong 0
b 0
i 0
em 0
Zawartość strony internetowej powinno zawierać więcej niż 250 słów, z stopa tekst / kod jest wyższy niż 20%.
Pozycji używać znaczników (h1, h2, h3, ...), aby określić temat sekcji lub ustępów na stronie, ale zwykle, użyj mniej niż 6 dla każdego tagu pozycje zachować swoją stronę zwięzły.
Styl używać silnych i kursywy znaczniki podkreślić swoje słowa kluczowe swojej stronie, ale nie nadużywać (mniej niż 16 silnych tagi i 16 znaczników kursywy)

Statystyki strony

twitter:title pusty
twitter:description pusty
google+ itemprop=name pusty
Pliki zewnętrzne 31
Pliki CSS 6
Pliki javascript 25
Plik należy zmniejszyć całkowite odwołanie plików (CSS + JavaScript) do 7-8 maksymalnie.

Linki wewnętrzne i zewnętrzne

Linki 143
Linki wewnętrzne 7
Linki zewnętrzne 136
Linki bez atrybutu Title 105
Linki z atrybutem NOFOLLOW 0
Linki - Użyj atrybutu tytuł dla każdego łącza. Nofollow link jest link, który nie pozwala wyszukiwarkom boty zrealizują są odnośniki no follow. Należy zwracać uwagę na ich użytkowania

Linki wewnętrzne

back to top ↑ #topnbt

Linki zewnętrzne

java, struts 2, spring, hibernate, solr, mahout and hadoop tutorials tips and tricks http://www.beingjavaguys.com/
home
http://www.beingjavaguys.com/
java
http://www.beingjavaguys.com/p/core-java-tutorials.html
spring
http://www.beingjavaguys.com/p/spring-framework.html
hibernate
http://www.beingjavaguys.com/search/label/hibernate
jsp & servlet
http://www.beingjavaguys.com/search/label/jsp-servlet
jdbc
http://www.beingjavaguys.com/search/label/jdbc
solr
http://www.beingjavaguys.com/search/label/solr
others
http://www.beingjavaguys.com/search/label/others
java 8 lambda expressions (functional interfaces, variable capture, method references, default methods) http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html
nagesh chauhan https://plus.google.com/113669883250831796053
core-java http://www.beingjavaguys.com/search/label/core-java
java8 http://www.beingjavaguys.com/search/label/java8
no comments http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html&t=java 8 lambda expressions (functional interfaces, variable capture, method references, default methods)
 twitter http://twitter.com/home?status=java 8 lambda expressions (functional interfaces, variable capture, method references, default methods) -- http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html&title=java 8 lambda expressions (functional interfaces, variable capture, method references, default methods)
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html&title=java 8 lambda expressions (functional interfaces, variable capture, method references, default methods)
read more http://www.beingjavaguys.com/2016/02/java-8-lambda-expressions.html
java programming - introduction http://www.beingjavaguys.com/2016/02/java-introduction.html
nagesh chauhan https://plus.google.com/113669883250831796053
core-java http://www.beingjavaguys.com/search/label/core-java
no comments http://www.beingjavaguys.com/2016/02/java-introduction.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2016/02/java-introduction.html&t=java programming - introduction
 twitter http://twitter.com/home?status=java programming - introduction -- http://www.beingjavaguys.com/2016/02/java-introduction.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2016/02/java-introduction.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2016/02/java-introduction.html&title=java programming - introduction
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2016/02/java-introduction.html&title=java programming - introduction
read more http://www.beingjavaguys.com/2016/02/java-introduction.html
how first level caching works in hibernate - example http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html
nagesh chauhan https://plus.google.com/113669883250831796053
caching http://www.beingjavaguys.com/search/label/caching
hibernate http://www.beingjavaguys.com/search/label/hibernate
3 comments http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
- http://4.bp.blogspot.com/-c1q1v-k2w44/vgfdf1uwfoi/aaaaaaaabiq/z95iwk0ih-u/s1600/hibernate-first-level-caching.png
download source code http://1drv.ms/1q4rfou

download how first level caching works in hibernate project

http://1drv.ms/1q4rfou

spring security authentication and authorization example with database credentials

http://www.beingjavaguys.com/2014/05/spring-security-authentication-and.html

spring 4 restful web services with hibernate 4

http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html

spring security with hibernate using maven - authentication and authorization example

http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html

spring mvc - json response with @responsebody annotation (spring + json)

http://www.beingjavaguys.com/2014/05/json-response-with-responsebody_31.html

integrate neo4j (graph db) with java – neo4j with java (neo4j + java)

http://www.beingjavaguys.com/2014/07/neo4j-graph-db-with-java.html
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html&t=how first level caching works in hibernate - example
 twitter http://twitter.com/home?status=how first level caching works in hibernate - example -- http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html&title=how first level caching works in hibernate - example
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html&title=how first level caching works in hibernate - example
read more http://www.beingjavaguys.com/2014/11/how-first-level-caching-works-in.html
securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest) http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html
nagesh chauhan https://plus.google.com/113669883250831796053
oauth http://www.beingjavaguys.com/search/label/oauth
spring-mvc http://www.beingjavaguys.com/search/label/spring-mvc
spring-security http://www.beingjavaguys.com/search/label/spring-security
web-services http://www.beingjavaguys.com/search/label/web-services
18 comments http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
source code https://github.com/neel4software/springsecurityoauth2
http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=password&client_id=restapp&client_secret=restapp&username=beingjavaguys&password=spring@java http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=password&client_id=restapp&client_secret=restapp&username=beingjavaguys&password=spring@java
http://localhost:8080/springrestsecurityoauth/api/users/?access_token=8c191a0f-ebe8-42cb-bc18-8e80f2c4238e http://localhost:8080/springrestsecurityoauth/api/users/?access_token=8c191a0f-ebe8-42cb-bc18-8e80f2c4238e
http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=refresh_token&client_id=restapp&client_secret=restapp&refresh_token=7ac7940a-d29d-4a4c-9a47-25a2167c8c49 http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=refresh_token&client_id=restapp&client_secret=restapp&refresh_token=7ac7940a-d29d-4a4c-9a47-25a2167c8c49
here http://www.beingjavaguys.com/2014/05/json-response-with-responsebody_31.html
here http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html
git hub https://github.com/neel4software/springsecurityoauth2

get spring security and oauth2 integration source code from git hub

https://github.com/neel4software/springsecurityoauth2"

spring security authentication and authorization example with database credentials

http://www.beingjavaguys.com/2014/05/spring-security-authentication-and.html

spring 4 restful web services with hibernate 4

http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html

spring security with hibernate using maven - authentication and authorization example

http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html

spring mvc - json response with @responsebody annotation (spring + json)

http://www.beingjavaguys.com/2014/05/json-response-with-responsebody_31.html

integrate neo4j (graph db) with java – neo4j with java (neo4j + java)

http://www.beingjavaguys.com/2014/07/neo4j-graph-db-with-java.html
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html&t=securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest)
 twitter http://twitter.com/home?status=securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest) -- http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html&title=securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest)
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html&title=securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest)
read more http://www.beingjavaguys.com/2014/10/spring-security-oauth2-integration.html
spring security with hibernate using maven - authentication and authorization example http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html
nagesh chauhan https://plus.google.com/113669883250831796053
hibernate http://www.beingjavaguys.com/search/label/hibernate
spring-mvc http://www.beingjavaguys.com/search/label/spring-mvc
spring-security http://www.beingjavaguys.com/search/label/spring-security
5 comments http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
what is spring security http://www.beingjavaguys.com/2013/03/how-to-use-spring-security.html
login & logout with spring security http://www.beingjavaguys.com/2013/09/spring-security-example.html
spring security authentication and authorization http://www.beingjavaguys.com/2014/05/spring-security-authentication-and.html
dynamic web project with maven and import it in eclipse http://www.beingjavaguys.com/2013/08/spring-maven-web-application-in-eclipse.html
- http://3.bp.blogspot.com/-n4vsilcrasg/valeskgro0i/aaaaaaaabee/7vbv3all7zy/s1600/users-table.png
- http://4.bp.blogspot.com/-8gomudki77w/valezzz0gei/aaaaaaaabem/n9b0ob70sue/s1600/user-roles-table.png
spring hibernate integration http://www.beingjavaguys.com/2014/05/spring4-hibernate4-integration.html
- http://4.bp.blogspot.com/-pf3as1ypwlk/vallgsgfeoi/aaaaaaaabek/jewi9msbnwo/s1600/login.png
- http://2.bp.blogspot.com/-j0lmko-z2yi/valll65ra6i/aaaaaaaabes/4mjiqi0jtsc/s1600/untitledh.png
- http://2.bp.blogspot.com/-kxf39darduo/valmniptemi/aaaaaaaabe0/zmaojnpuahc/s1600/untitleduiui.png
spring security authentication and authorization http://www.beingjavaguys.com/2014/05/spring-security-authentication-and.html
download link http://1drv.ms/1pxn6as

download "spring security with hibernate example project" from "skydrive"

http://1drv.ms/1pxn6as
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html&t=spring security with hibernate using maven - authentication and authorization example
 twitter http://twitter.com/home?status=spring security with hibernate using maven - authentication and authorization example -- http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html&title=spring security with hibernate using maven - authentication and authorization example
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html&title=spring security with hibernate using maven - authentication and authorization example
read more http://www.beingjavaguys.com/2014/08/spring-security-with-hibernate.html
spring 4 restful web services with hibernate 4 example using maven – server application http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html
nagesh chauhan https://plus.google.com/113669883250831796053
hibernate http://www.beingjavaguys.com/search/label/hibernate
spring-mvc http://www.beingjavaguys.com/search/label/spring-mvc
web-services http://www.beingjavaguys.com/search/label/web-services
32 comments http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html#comment-form
ask a question http://www.techburps.com/faq/users/ask-questions/?ref=bjg
dynamic web project with maven and import it in eclipse http://www.beingjavaguys.com/2013/08/spring-maven-web-application-in-eclipse.html
spring hibernate integration http://www.beingjavaguys.com/2014/05/spring4-hibernate4-integration.html
spring json – output json in spring application http://www.beingjavaguys.com/2014/05/json-response-with-responsebody_31.html
spring hibernate integration http://www.beingjavaguys.com/2014/05/spring4-hibernate4-integration.html
download link http://1drv.ms/1qaxsxl
chrome's postman - rest client https://chrome.google.com/webstore/detail/postman-rest-client/fdmmgilgnpjigdojojpjoooidkmcomcm?hl=en

download "spring 4 restful web services with hibernate 4 example" from "skydrive"

http://1drv.ms/1qaxsxl
 facebook http://www.facebook.com/share.php?v=4&src=bm&u=http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html&t=spring 4 restful web services with hibernate 4 example using maven – server application
 twitter http://twitter.com/home?status=spring 4 restful web services with hibernate 4 example using maven – server application -- http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html
 google+ https://plus.google.com/share?url=http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html
 stumble http://www.stumbleupon.com/submit?url=http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html&title=spring 4 restful web services with hibernate 4 example using maven – server application
 digg http://digg.com/submit?phase=2&url=http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html&title=spring 4 restful web services with hibernate 4 example using maven – server application
read more http://www.beingjavaguys.com/2014/08/spring-restful-web-services.html
older posts → http://www.beingjavaguys.com/search?updated-max=2014-08-14t12:34:00-07:00&max-results=10
home http://www.beingjavaguys.com/
posts (atom) http://www.beingjavaguys.com/feeds/posts/default
write an article, we will publish it here in your name http://www.beingjavaguys.com/p/we-knows-how-much-love-and-support-we.html
fresher jobs and walkin - india http://www.beingjavaguys.com/p/fresher-jobs-and-walkin-delhi-noida.html
java, struts 2, spring, hibernate, solr, mahout and hadoop tutorials tips and tricks http://www.beingjavaguys.com/
www.t20worldcup2020.com http://www.t20worldcup2020.com/
blogger http://www.blogger.com/
mythemeshop http://mythemeshop.com/
newbloggerthemes.com http://newbloggerthemes.com/
hip hop beats https://soundcloud.com/hiphop-beats

Zdjęcia

Zdjęcia 6
Zdjęcia bez atrybutu ALT 6
Zdjęcia bez atrybutu TITLE 6
Korzystanie Obraz ALT i TITLE atrybutu dla każdego obrazu.

Zdjęcia bez atrybutu TITLE

http://4.bp.blogspot.com/-c1q1v-k2w44/vgfdf1uwfoi/aaaaaaaabiq/z95iwk0ih-u/s1600/hibernate-first-level-caching.png
http://3.bp.blogspot.com/-n4vsilcrasg/valeskgro0i/aaaaaaaabee/7vbv3all7zy/s320/users-table.png
http://4.bp.blogspot.com/-8gomudki77w/valezzz0gei/aaaaaaaabem/n9b0ob70sue/s320/user-roles-table.png
http://4.bp.blogspot.com/-pf3as1ypwlk/vallgsgfeoi/aaaaaaaabek/jewi9msbnwo/s1600/login.png
http://2.bp.blogspot.com/-j0lmko-z2yi/valll65ra6i/aaaaaaaabes/4mjiqi0jtsc/s1600/untitledh.png
http://2.bp.blogspot.com/-kxf39darduo/valmniptemi/aaaaaaaabe0/zmaojnpuahc/s1600/untitleduiui.png

Zdjęcia bez atrybutu ALT

http://4.bp.blogspot.com/-c1q1v-k2w44/vgfdf1uwfoi/aaaaaaaabiq/z95iwk0ih-u/s1600/hibernate-first-level-caching.png
http://3.bp.blogspot.com/-n4vsilcrasg/valeskgro0i/aaaaaaaabee/7vbv3all7zy/s320/users-table.png
http://4.bp.blogspot.com/-8gomudki77w/valezzz0gei/aaaaaaaabem/n9b0ob70sue/s320/user-roles-table.png
http://4.bp.blogspot.com/-pf3as1ypwlk/vallgsgfeoi/aaaaaaaabek/jewi9msbnwo/s1600/login.png
http://2.bp.blogspot.com/-j0lmko-z2yi/valll65ra6i/aaaaaaaabes/4mjiqi0jtsc/s1600/untitledh.png
http://2.bp.blogspot.com/-kxf39darduo/valmniptemi/aaaaaaaabe0/zmaojnpuahc/s1600/untitleduiui.png

Ranking:


Alexa Traffic
Daily Global Rank Trend
Daily Reach (Percent)









Majestic SEO











Text on page:

java, struts 2, spring, hibernate, solr, mahout and hadoop tutorials tips and tricks java and j2ee tutorials, jsp and servlet tutorials, spring mvc, solr, xml, json examples, hibernate & struts 2 hello world projects --> --> home java spring hibernate jsp & servlet jdbc solr others saturday, 27 february 2016 java 8 lambda expressions (functional interfaces, variable capture, method references, default methods) nagesh chauhan 09:28 core-java, java8 no comments ask a question in this article we will discuss about most exiting release of java ever, java 8 and its new features like lambda expressions and streams. java 8 lambda expressions in this particular section we will come to know syntax and functioning of java 8 lambdas, following are the breakups: 1) concept 2) syntax 3) functional interfaces 4) variable capture 5) method references 6) default methods java 8 lambda concept the mathematica foundation of lambda calculus was stated in 1930 and than most of the programming languages started using the concept from 1960 to till data, before java other languages like c++, python, js etc are already having the concept in them. what are lambdas good for ? : lambda expressions are the basics of functional programming; can be used to define anonymous functions, can be assigned to a variable, can be passed to a function and can be returned from a function. other than this lambda expressions made the parallel programming easier, help programmers to write compact, cleaner and richer data structures code and api's. java 8 lambda syntax we have seen what are lambda theoretically, what are other languages already using the concept and how can lambda help us in cleaner code writing; now lets see how java 8 does it: example 1: printing a list of integers list list = arrays.aslist(1, 2, 3, 4, 5); list.foreach(i -> system.out.print(i)); output: 12345 foreach() is a method that accepts a function as input and calls the function for each value of the collection. i -> system.out.print(i), is an lambda expression, this defines an anonymous function with one parameter i of type integer. example 2: printing a list of integers by adding 10 to them list list = arrays.aslist(1, 2, 3, 4, 5); list.foreach(i -> { int addnumber = 10; i = i + addnumber; system.out.print(i); }); output: 11,12,13,14,15, as said earlier we can pass a function to foreach(), if we have single line we don't need to put body of the function {} as in example 1, but for multiple line we need ro put {} as in example 2. we can define variable, do calculation and everything that can be done in a body of a function. example 3: function parameter with a type list list = arrays.aslist(1, 2, 3, 4, 5); list.foreach((integer i) -> system.out.print(i + ",")); output: 1,2,3,4,5, we can define the type of parameter “i” as integer, but that is optional because java compiler is smart enough to identify the type. lambda expression life cycle lambda expressions do have a life cycle as well, when compiler sees a lambda expression than it converts it to a function and than calls that function: i -> system.out.print(i) // lambda expresson is converted to: public static void generatednameforlambda(integer i){ system.out.println(i); } java 8 lambda functional interfaces any java developer around the globe has used at least one of the followig interface in their application: java.lang.runnable, java.awt.event.actionlistener, java.util.comparator, java.util.concurrent.callable. these interfaces has one thing in common, that these interfaces had only one method in them. these interfaces can be represented uisng java 8 lambda expression. there is a @functionalinterface annotation to put on functional interfaces, this will throw an error if put on a wrong implementation of functional interface. @functionalinterface public interface simplefuncinterface { public void dowork(); } so this @functionalinterface annotation has a backword compatibility as well, any interface having one method even compiled with java 1.0 is comatible with java 8 as a functional interface. example 4: assigning lambda to interfaces now we can assign lambda expressions to these functional interfaces as well, we have an functional interface named consumer in java.util.function: public interface consumer{ void accept(t t); } we can assign a lambda expression to this consumer iterface as follows : list list = arrays.aslist(1, 2, 3, 4, 5); consumer consumer = i -> system.out.print(i); list.foreach(consumer); output: 12345 exampel 5: return an lambda expression @functionalinterface interface calculator { public integer add(integer i1, integer i2); } public calculator addnumbers() { return (i1, i2) -> i1 + i2; } public void dosomething(calculator c) { system.out.println(c.add(123, 120)); } calculator c = addnumbers(); dosomething(c); output: 243 here we can see addnumbers() is returning an lambda expression, we have already seen lambda expressions can be assigned or represented as functional interfaces. java 8 lambda variable capture variable capture is nothing but the ability of lambdas to identify and use variables outside the expression. local variable example 6: capturing a local variable inside expressions list list = arrays.aslist(1, 2, 3, 4, 5); int v = 10; list.foreach(i -> system.out.print((i + v)+",")); output: 11,12,13,14,15, this is simple, local variables outside expression can be used easily. but if we try to modify local variables defined outside expression, the compiler will through an exception saying: “local variable v defined in an enclosing scope must be final or effectively final” list list = arrays.aslist(1, 2, 3, 4, 5); int v = 10; list.foreach(i -> { v++; // will not compile system.out.print((i + v) + ","); }); example 7: capturing a static variable inside expressions the same is true with static variables as well: static int v = 10; public static void main(string[] args) { list list = arrays.aslist(1, 2, 3, 4, 5); list.foreach(i -> { system.out.print((i + v) + ","); }); } unlike anonymous inner classes, this keyword in lambda expressions points to the this of enclosing class. lambda are not anonymous inner classes lambda expressions looks like anonymous inner classes but they are completely different, below are the points in favor of that: 1) anonymous inner classes can have states in form of class level instance, but lambda can not have that. 2) anonymous inner classes can have a number of different methods in them, but lambda can have single method only. 3) keyword “this“ ponts to the object instance of the anonymous inner class but “this” in labda points to the enclosong class. java 8 lambda method references so far we have seen, we can pass a anonymous function as a lambda during lambda expressions, but we can also reference an already created function in a lambda expression as follows: example 8: passing a reference of existing method as lambda public class impl { public static void main(string[] args) { // way 1 of passing existing static method as lambda consumer consumer1 = i -> dosomething(i); consumer1.accept(1); // way 2 of passing existing static method as lambda consumer consumer2 = impl::dosomething; consumer2.accept(1); } public static void dosomething(integer i) { system.out.println(i); } } output: 1 1 we have an elready created static method dosomething(integer i), we can pass it to functional interface consuler because both accept(integer i) and dosomething(integer i) have same signature. we can do the same in two ways as shown above. in the examples above the code works because consumer is having accept(integer i) single paramater of type integer and does not return anything and same is the condition with dosomething(integer i). to pass a already exiting method as a function in lambda expressions; the signature of referenced method need to match with signature of functional interface method. example 9: referencing a constructor a constructor can be passed to a mapper in following two ways: // way 1 of passing existing constructor as lambda function mapper1 = x -> new integer(x); system.out.println(mapper1.apply("12")); // way 2 of passing existing constructor as lambda function mapper2 = integer::new; system.out.println(mapper2.apply("11")); output: 1 in the above code we are telling the compiler to create a method and in the body of method accept string parameter and convert it to integer. java 8 default methods in interfaces when java 8 features start building the top most challenge was back support meaning that, every new functionality should not affect existing code. default void foreach(consumer action) for instance we have a java 8 method foreach() in iterable interface, as per old interface conventions if we have unimplemented methods in an interface than its implementation class has to override it and hence all list implementation were forced to override foreach(). the alternative to that was created with default methods, these methods has not to be implemented by any implementation class forcefully. example 10: default methods interface interfacea{ public void a(); default void b(){ // some implementation } } class classa implements interfacea{ @override public void a() { // todo auto-generated method stub } } the code written above works fine and does not give any compilation error, we have a non-abstract method in interfacea that workds because a new keyword “default” can be used for doing so. secondly we are not forced to override b() in implementation class interfacea. this is where we needed to have default type of methods. the default methods written in interfaces are already having an impersonation and do not forced the implemented class to inherit them, but one can inherit them as well as in traditional manner and in that case the overridden functionality will be taken into account: interface interfacea { public void a(); default void b() { system.out.println("interfacea"); } } class classa implements interfacea { @override public void a() { // todo auto-generated method stub } @override public void b() { system.out.println("classa"); } } this is all for this article, we have seen a lot of implmentation od lambda expressions. these expressions keeps the code compact and are very handy while dealing with java 8 streams. we will see more bout java 8 stream in next examples. facebook twitter google+ stumble digg read more saturday, 20 february 2016 java programming - introduction nagesh chauhan 20:46 core-java no comments ask a question java is a most commonly used and widely accepted object oriented programming language of today. when it comes to choosing an programming language for companies and individuals to develop a simple or complicated enterprise web application they choose java. java is an open source programming language with a support of wide community. what is java ? 1) java is an open source, object oriented programming language originally developed by james gosling under the roof of sun microsystems in 1995. 2) java applications are platform independent, i.e. any java program written and compiled on one platform can run on any other platform of same or distinct type. 3) java can be used for desktop or web or middle-ware application development, core java, jsp, servlet are most commonly used java variants. 4) most popular mobile operating system android applications are written and developed in simple core java. properties of java 1) open-source : java is an open source programming language, java source code is open to all and one can change the code and compile again to use java in its own way. 2) platform independent: java is purely platform independent, any java program written and developed on one platform can run on any other platform without recompiling it. 3) simple: java has a very simple and easy to understand syntax, most of the terms are inherited from c and c++ programming languages. one who has studied c or c++ can start with java in no time. 4) secure: java is secure, one can write virus free, authentic and secure code with help of java authentication and security mechanism. 5) multi-threaded: java is a multi threaded programming language, that means one can write a effective multi threaded application in java to utilize most of cpu and memory. 6) distributed: java os designed to be used in a network distributed way, rmi is an example of java's distributed way of working. 7) dynamic: despite a lot of other features java also has a dynamic nature, it is considered more dynamic than c and c++ because of its adopting nature towards changing technology. java tools one can start write code in java even with notepad, as far as jdk is installed on the system, although more sofesticated and managed ide's are also there like, eclipse, netbeans and intellij. facebook twitter google+ stumble digg read more saturday, 15 november 2014 how first level caching works in hibernate - example nagesh chauhan 13:18 caching, hibernate 3 comments ask a question in computer science caching is a practice that stores data in memory to increase performance by reducing the number of database hits. in a caching procedure we stores frequently asked data into memory so than next time a similar request came to the application the data can be served from the cache memory without fetching it again and again from the database. it helps us to reduce the number of database hits and hence increases performance. caching in hibernate while hibernate proved itself an efficient and useful tool in java community, it provides three type of in build caching techniques, we call them first level caching, second level caching and query caching. first level caching in hibernate first level caching is enabled by default and we don’t need to do anything to achieve it, in fact we can’t even disable it from there. first level caching is also called session level caching meaning that it works for a session only, in case same query is being executed two or more times in a single session it gets data from the db for the very first request only and serves the same data from cache for all upcoming similar requests. how first level caching works in hibernate first level cache is associated with sessions only, when the query is executed first time it gets the data from the database and save that data to cache memory. the data that is stored in cache at first occurrence of query is being served for all upcoming similar requests until the session is alive. once a session is closed all first level cache are cleared. we can remove a particular loaded entity from the cache using evict() and entire cache can be cleared using clear(). once the cache is cleared with any of the two methods it will query to the database again for a new call even if the session is not closed yet. src\main\java\com\beingjavaguys\sample\cachingimpl.java package com.beingjavaguys.sample; import org.hibernate.session; import org.hibernate.sessionfactory; import org.hibernate.transaction; import com.beingjavaguys.models.employee; import com.beingjavaguys.utils.hibernateutils; /** * @author nagesh.chauhan * */ public class cachingimpl { public static void main(string[] args) { sessionfactory sessionfactory = hibernateutils.getsessionfactory(); // create an employee object to persist in db employee employee = new employee("eddy", "smith", "eddy@beingjavaguys.com", "9898787676"); // lets save few data in employee table session session = sessionfactory.opensession(); transaction transaction = session.begintransaction(); session.save(employee); transaction.commit(); session.close(); system.out.println("****data creation completed****"); session session1 = sessionfactory.opensession(); system.out.println("****created session 1****"); transaction = session1.begintransaction(); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); transaction.commit(); session1.close(); system.out.println("****closed session 1****"); session session2 = sessionfactory.opensession(); system.out.println("****created session 2****"); transaction = session2.begintransaction(); employee = (employee) session2.load(employee.class, 1l); system.out.println(employee.getfirstname()); transaction.commit(); session2.close(); system.out.println("****closed session 2****"); } } ****created session 1**** hibernate: select employee0_.id as id1_0_0_, employee0_.email as email2_0_0_, employee0_.first_name as first_na3_0_0_, employee0_.last_name as last_nam4_0_0_, employee0_.phone as phone5_0_0_ from employee employee0_ where employee0_.id=? eddy eddy eddy ****closed session 1**** ****created session 2**** hibernate: select employee0_.id as id1_0_0_, employee0_.email as email2_0_0_, employee0_.first_name as first_na3_0_0_, employee0_.last_name as last_nam4_0_0_, employee0_.phone as phone5_0_0_ from employee employee0_ where employee0_.id=? eddy ****closed session 2**** you can see that for session1 we have requested the entity three times but the query is being executed only once and for second and third request the data saved in the cache is served. we closed the session1 and created new session2, this time we requested same entity from database but it went to get data from db because the cached data is cleared when session1 get closed. here is what happened. 1) we requested for the employee entity first time, hibernate checked if the object is available on first level cache; the object is not there so the entity is requested from the database. and a copy of that is stored on cache. 2) now second request came for employee entity, this time the entity was present on cache so no db call made and entity served from the cache. 3) now third request came for employee entity, this time the entity was present on cache so no db call made and entity served from the cache. 4) session (session1) is closed so all the first level cache data associated with is removed. 5) a new session (session2) being created. 6) a request came to get employee entity, hibernate checked if the object is available on first level cache, the object is not there so the entity is requested from form the database. and a copy of that is stored on cache. how evict() and clear() works in hibernate we can’t disable first level cache in hibernate but we can clear a particular entity cache with evict() and whole cache with clear(). the example below explains the same. src\main\java\com\beingjavaguys\sample\evictimpl.java package com.beingjavaguys.sample; import org.hibernate.session; import org.hibernate.sessionfactory; import org.hibernate.transaction; import com.beingjavaguys.models.employee; import com.beingjavaguys.utils.hibernateutils; /** * @author nagesh.chauhan * */ public class evictimpl { public static void main(string[] args) { sessionfactory sessionfactory = hibernateutils.getsessionfactory(); // create an employee object to persist in db employee employee = new employee("eddy", "smith", "eddy@beingjavaguys.com", "9898787676"); // lets save few data in employee table session session = sessionfactory.opensession(); transaction transaction = session.begintransaction(); session.save(employee); transaction.commit(); session.close(); system.out.println("****data creation completed****"); session session1 = sessionfactory.opensession(); system.out.println("****created session****"); transaction = session1.begintransaction(); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); // removed employee entity from the cache session1.evict(employee); system.out.println("****removed employee entity from the cache****"); employee = (employee) session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); transaction.commit(); session1.close(); system.out.println("****closed session****"); } } ****created session**** hibernate: select employee0_.id as id1_0_0_, employee0_.email as email2_0_0_, employee0_.first_name as first_na3_0_0_, employee0_.last_name as last_nam4_0_0_, employee0_.phone as phone5_0_0_ from employee employee0_ where employee0_.id=? eddy eddy ****removed employee entity from the cache**** hibernate: select employee0_.id as id1_0_0_, employee0_.email as email2_0_0_, employee0_.first_name as first_na3_0_0_, employee0_.last_name as last_nam4_0_0_, employee0_.phone as phone5_0_0_ from employee employee0_ where employee0_.id=? eddy ****closed session**** we can see that, we requested employee entity three times again, here is what happened : 1) we requested for the employee hibernate checked if the object is available on first level cache, the object is not there so the entity is requested from form the database. and a copy of that is stored on cache. 2) next time same request came for employee entity, this time the entity was present on cache so no db call made and entity served from the cache. 3) a request came to remove entity from the cache, now cache does not have a cached entity. 4) third request came to get employee entity, hibernate checked if the object is available on first level cache, the object is not there so the entity is requested from form the database. and a copy of that is stored on cache. we look into how evict() works for hibernate, clear works in the same way except that clear() removes all the entities form the cache. here we are done with how first level cache works in hibernate and how evict() and clear() works in hibernate. we came to know how we can clear hibernate cache using evict() and clear(). in coming articles we will see how to what is second level caching and query caching in hibernate. complete source code and configuration can be found in the attached sample project. download it from here: download source code thanks for reading ! being java guys team download how first level caching works in hibernate project related posts spring security authentication and authorization example with database credentials spring 4 restful web services with hibernate 4 spring security with hibernate using maven - authentication and authorization example spring mvc - json response with @responsebody annotation (spring + json) integrate neo4j (graph db) with java – neo4j with java (neo4j + java) facebook twitter google+ stumble digg read more saturday, 18 october 2014 securing restful web services with spring security and oauth2 (spring security + oauth2 + spring rest) nagesh chauhan 03:27 oauth, spring-mvc, spring-security, web-services 18 comments ask a question oauth (open authentication) is an open standard or kind of protocol that lets one site to share its content with some other site without sharing credentials. the source code of this application can be found on git hub: source code in this post we will discuss how to secure restful web services using spring security and oauth2, we will use spring security to validate a user on server and oauth to manage authentication tokens to be used in communication. after applying this implementation only authenticated users and applications will get a valid access token from oauth and using that token the user can access authorized api’s on server. the flow of application will go something like this: 1) user sends a get request to server with five parameters: grant_type, username, password, client_id, client_secret; something like this: http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=password&client_id=restapp&client_secret=restapp&username=beingjavaguys&password=spring@java 2) server validates the user with help of spring security, and if the user is authenticated, oauth generates a access token and send sends back to user in following format. { "access_token": "22cb0d50-5bb9-463d-8c4a-8ddd680f553f", "token_type": "bearer", "refresh_token": "7ac7940a-d29d-4a4c-9a47-25a2167c8c49", "expires_in": 119 } here we got access_token for further communication with server or to get some protected resourses(api’s), it mentioned a expires_in time that indicates the validation time of the token and a refresh_token that is being used to get a new token when token is expired. 3) we access protected resources by passing this access token as a parameter, the request goes something like this: http://localhost:8080/springrestsecurityoauth/api/users/?access_token=8c191a0f-ebe8-42cb-bc18-8e80f2c4238e here http://localhost:8080/springrestsecurityoauth is the server path, and /api/users/ is an api url that returns a list of users and is being protected to be accessed. 4) if the token is not expired and is a valid token, the requested resources will be returned. 5) in case the token is expired, user needs to get a new token using its refreshing token that was accepted in step(2). a new access token request after expiration looks something like this: http://localhost:8080/springrestsecurityoauth/oauth/token?grant_type=refresh_token&client_id=restapp&client_secret=restapp&refresh_token=7ac7940a-d29d-4a4c-9a47-25a2167c8c49 and you will get a new access token along with a new refresh token. integrating spring security with oauth2 to secure restful web services. in this section we will see how the application works and how to integrate spring security with oauth2, so for now we have a simple spring rest structure that returns a list of users for authenticated user, we have a simple spring controller that’s taking the responsibility: more on @responsebody : here \src\main\java\com\beingjavaguys\controllers\restcontroller.java package com.beingjavaguys.controllers; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import org.springframework.stereotype.controller; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestmethod; import org.springframework.web.bind.annotation.responsebody; import com.beingjavaguys.models.user; import com.beingjavaguys.services.dataservice; /** * @author nagesh.chauhan * */ @controller @requestmapping("/api/users") public class restcontroller { @autowired dataservice dataservice; @requestmapping(value = "/", method = requestmethod.get) @responsebody public list list() { return dataservice.getuserlist(); } } the code is self explainer, we are having an uri (/api/users/) to be accessed by a get request and it will return a list of users as a response. we are using simple service structure to get data, for now the data is being returned in a harcoded way but it can be kind of dynamic of from database. more on spring rest web services : here \src\main\java\com\beingjavaguys\services\dataservice.java package com.beingjavaguys.services; import java.util.list; import com.beingjavaguys.models.user; /** * @author nagesh.chauhan * */ public interface dataservice { public list getuserlist(); } \src\main\java\com\beingjavaguys\services\dataserviceimpl.java we have created three users and added them to a list, this list will be accessed to authenticated users only with the help of auhentication oauth token. package com.beingjavaguys.services; import java.util.arraylist; import java.util.list; import org.springframework.stereotype.service; import com.beingjavaguys.models.user; /** * @author nagesh.chauhan * */ @service public class dataserviceimpl implements dataservice { @override public list getuserlist() { // preparing user list with few hard coded values list userlist = new arraylist(); userlist.add(new user(1, "user_a", "user_a@example.com", "9898989898")); userlist.add(new user(2, "user_b", "user_b@example.com", "9767989898")); userlist.add(new user(3, "user_c", "user_c@example.com", "9898459898")); return userlist; } } dependencies required to integrate spring mvc , spring security and oauth2 4.0.0 com.beingjavaguys.sample springrestsecurityoauth war 1.0-snapshot springrestsecurityoauth maven webapp http://maven.apache.org 4.0.7.release 1.2.17 1.7 springrestsecurityoauth 3.2.5.release ${pom.artifactid} maven-compiler-plugin ${jdk.version} ${jdk.version} org.apache.commons commons-io 1.3.2 log4j log4j ${log4j.version} org.springframework spring-web ${spring.version} org.springframework spring-webmvc ${spring.version} org.springframework.security spring-security-web ${spring.security.version} org.springframework.security spring-security-config ${spring.security.version} org.springframework.security.oauth spring-security-oauth2 1.0.0.release com.google.code.gson gson 2.2.2 org.codehaus.jackson jackson-mapper-asl 1.9.10 commons-httpclient commons-httpclient 3.1 org.springframework spring-context-support ${spring.version} javax.servlet javax.servlet-api 3.0.1 provided spring security oauth configuration now this is where the actual thing is happening, we need to configure a number of thing in this security configuration file: \src\main\webapp\web-inf\spring-security.xml spring configuration file this is nothing more that a very simple spring configuration file, it just loads spring web app context in the container, we can configure spring related thing here: \src\main\webapp\web-inf\mvc-dispatcher-servlet.xml deployment descriptor this is simple web.xml file that lets the container know that all upcoming requests will be handled by spring itself, we have passed location of configuration files and added a spring security filter over here. this filter is intercepting all requests to be authenticated by security context. \src\main\webapp\web-inf\web.xml sample spring maven project mvc-dispatcher org.springframework.web.servlet.dispatcherservlet 1 mvc-dispatcher / org.springframework.web.context.contextloaderlistener contextconfiglocation /web-inf/mvc-dispatcher-servlet.xml, /web-inf/spring-security.xml springsecurityfilterchain org.springframework.web.filter.delegatingfilterproxy springsecurityfilterchain /* domain classes here is a single domain class, whose objects are going to be returned in json format: \src\main\java\com\beingjavaguys\models\user.java package com.beingjavaguys.models; /** * @author nagesh.chauhan * */ public class user { private int id; private string name; private string email; private string phone; public user() { super(); // todo auto-generated constructor stub } public user(int id, string name, string email, string phone) { super(); this.id = id; this.name = name; this.email = email; this.phone = phone; } public int getid() { return id; } public void setid(int id) { this.id = id; } public string getname() { return name; } public void setname(string name) { this.name = name; } public string getemail() { return email; } public void setemail(string email) { this.email = email; } public string getphone() { return phone; } public void setphone(string phone) { this.phone = phone; } } this is all about, securing restful web services with spring security and oauth2, in this article we look into how to configure spring security with oauth2 to use a token based authentication mechanism. in upcoming articles we will see more about security in java ee applications. download complete project : git hub thanks for reading ! being java guys team get spring security and oauth2 integration source code from git hub related posts spring security authentication and authorization example with database credentials spring 4 restful web services with hibernate 4 spring security with hibernate using maven - authentication and authorization example spring mvc - json response with @responsebody annotation (spring + json) integrate neo4j (graph db) with java – neo4j with java (neo4j + java) facebook twitter google+ stumble digg read more sunday, 31 august 2014 spring security with hibernate using maven - authentication and authorization example nagesh chauhan 01:21 hibernate, spring-mvc, spring-security 5 comments ask a question in our previous discussions we came across a number of implementations in spring security, what is spring security, login & logout with spring security, spring security authentication and authorization in this particular blog we will see how to configure spring security with hibernate to accomplish authentication and authorization in our application. we will use a maven web project for the purpose, we have just created a simple maven web project and imported it in eclipse. more details on : dynamic web project with maven and import it in eclipse database setup for spring security and hibernate integration before we go forward let's first create a database and required tables to store and get user credential from, we have created two tables "users" and "user_roles". we have added two users details, with role_user and role_admin to be used here. just copy and execute the below script in your mysql query editor to get a db setup for you. -- dumping database structure for spring_social_db create database if not exists `spring_social_db` /*!40100 default character set latin1 */; use `spring_social_db`; -- dumping structure for table spring_social_db.users create table if not exists `users` ( `username` varchar(45) not null, `enabled` bit(1) not null, `password` varchar(60) not null, primary key (`username`) ) engine=innodb default charset=latin1; -- dumping data for table spring_social_db.users: ~2 rows (approximately) /*!40000 alter table `users` disable keys */; insert into `users` (`username`, `enabled`, `password`) values ('admin', b'10000000', 'admin@123'), ('user', b'10000000', 'user@123'); /*!40000 alter table `users` enable keys */; -- dumping structure for table spring_social_db.user_roles create table if not exists `user_roles` ( `user_role_id` int(11) not null auto_increment, `role` varchar(45) not null, `username` varchar(45) not null, primary key (`user_role_id`), key `fk_9ry105icat2dux14oyixybw9l` (`username`), constraint `fk_9ry105icat2dux14oyixybw9l` foreign key (`username`) references `users` (`username`) ) engine=innodb auto_increment=4 default charset=latin1; -- dumping data for table spring_social_db.user_roles: ~3 rows (approximately) /*!40000 alter table `user_roles` disable keys */; insert into `user_roles` (`user_role_id`, `role`, `username`) values (1, 'role_admin', 'admin'), (2, 'role_user', 'user'), (3, 'role_user', 'admin'); /*!40000 alter table `user_roles` enable keys */; /*!40014 set foreign_key_checks=1 */; /*!40101 set character_set_client=@old_character_set_client */; if everything goes right you will see following table structures. dependencies required for spring security with hibernate integration pom.xml 4.0.0 com.beingjavaguys.sample sp_sc_hibernate war 1.0-snapshot sp_sc_hibernate maven webapp http://maven.apache.org 4.0.6.release 4.3.6.final 1.2.17 1.7 1.2 5.1.6 3.2.5.release sp_sc_hibernate ${pom.artifactid} maven-compiler-plugin ${jdk.version} ${jdk.version} org.hibernate hibernate-entitymanager ${hibernate.version} log4j log4j ${log4j.version} org.springframework spring-orm ${spring.version} org.springframework spring-jdbc ${spring.version} org.springframework spring-web ${spring.version} org.springframework spring-webmvc ${spring.version} org.springframework.security spring-security-web ${spring.security.version} org.springframework.security spring-security-config ${spring.security.version} org.springframework.security spring-security-taglibs ${spring.security.version} jstl jstl ${jstl.version} mysql mysql-connector-java ${mysql_connector.version} \src\main\webapp\web-inf\web.xml we need to make an spring entry to web.xml, this will tell the container that all upcoming requests will be served by spring framework itself as per the configuration. we have also added a filter entry to integrate spring security in the application. sample spring maven project mvc-dispatcher org.springframework.web.servlet.dispatcherservlet 1 mvc-dispatcher / org.springframework.web.context.contextloaderlistener contextconfiglocation /web-inf/mvc-dispatcher-servlet.xml, /web-inf/spring-security.xml springsecurityfilterchain org.springframework.web.filter.delegatingfilterproxy springsecurityfilterchain /* \src\main\webapp\web-inf\spring-config.xml this is simple spring configuration file, we have added entry for base-package here to search and find controller, dao and service classes with annotations. we defined few beans here for hibernate configurations and a datasource bean to connect with database. more details on : spring hibernate integration com.beingjavaguys.models.login.users com.beingjavaguys.models.login.userrole org.hibernate.dialect.mysql5dialect ${hibernate.show_sql} update /web-inf/pages/ .jsp spring security configuration file \src\main\webapp\web-inf\spring-security.xml here is spring-security configuration file with all required configurations and settings, we have defioned two roles here and a service "loginservice" bean to communicate with data layer of the application. login controller code \src\main\java\com\beingjavaguys\controller\logincontroller.java this is simple spring mvc controller having request mappings to deal with different incoming request and render appropriate pages used in the login process. package com.beingjavaguys.controller; import org.springframework.security.authentication.anonymousauthenticationtoken; import org.springframework.security.core.authentication; import org.springframework.security.core.context.securitycontextholder; import org.springframework.security.core.userdetails.userdetails; import org.springframework.stereotype.controller; import org.springframework.web.bind.annotation.modelattribute; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestparam; import org.springframework.web.servlet.modelandview; import com.beingjavaguys.models.login.users; @controller public class logincontroller { @requestmapping(value = { "/", "/home" }) public string getuserdefault() { return "home"; } @requestmapping("/login") public modelandview getloginform(@modelattribute users users, @requestparam(value = "error", required = false) string error, @requestparam(value = "logout", required = false) string logout) { string message = ""; if (error != null) { message = "incorrect username or password !"; } else if (logout != null) { message = "logout successful !"; } return new modelandview("login", "message", message); } @requestmapping("/admin**") public string getadminprofile() { return "admin"; } @requestmapping("/user**") public string getuserprofile() { return "user"; } @requestmapping("/403") public modelandview getaccessdenied() { authentication auth = securitycontextholder.getcontext() .getauthentication(); string username = ""; if (!(auth instanceof anonymousauthenticationtoken)) { userdetails userdetail = (userdetails) auth.getprincipal(); username = userdetail.getusername(); } return new modelandview("403", "username", username); } } model classes to represent "user" and "user_role" tables in database \src\main\java\com\beingjavaguys\models\login\users.java package com.beingjavaguys.models.login; import java.util.hashset; import java.util.set; import javax.persistence.column; import javax.persistence.entity; import javax.persistence.fetchtype; import javax.persistence.id; import javax.persistence.onetomany; import javax.persistence.table; @entity @table(name = "users", catalog = "spring_social_db") public class users { @id @column(name = "username", unique = true, nullable = false, length = 45) private string username; @column(name = "password", nullable = false, length = 60) private string password; @column(name = "enabled", nullable = false) private boolean enabled; @onetomany(fetch = fetchtype.lazy, mappedby = "user") private set userrole = new hashset(0); public string getusername() { return username; } public void setusername(string username) { this.username = username; } public string getpassword() { return password; } public void setpassword(string password) { this.password = password; } public boolean isenabled() { return enabled; } public void setenabled(boolean enabled) { this.enabled = enabled; } public set getuserrole() { return userrole; } public void setuserrole(set userrole) { this.userrole = userrole; } } \src\main\java\com\beingjavaguys\models\login\userrole.java package com.beingjavaguys.models.login; import javax.persistence.column; import javax.persistence.entity; import javax.persistence.fetchtype; import javax.persistence.generatedvalue; import javax.persistence.generationtype; import javax.persistence.id; import javax.persistence.joincolumn; import javax.persistence.manytoone; import javax.persistence.table; @entity @table(name = "user_roles", catalog = "spring_social_db") public class userrole { @id @generatedvalue(strategy = generationtype.identity) @column(name = "user_role_id", unique = true, nullable = false) private integer userroleid; @manytoone(fetch = fetchtype.lazy) @joincolumn(name = "username", nullable = false) private users user; @column(name = "role", nullable = false, length = 45) private string role; public integer getuserroleid() { return userroleid; } public void setuserroleid(integer userroleid) { this.userroleid = userroleid; } public users getuser() { return user; } public void setuser(users user) { this.user = user; } public string getrole() { return role; } public void setrole(string role) { this.role = role; } } data layer for spring security and hibernate configuration \src\main\java\com\beingjavaguys\dao\login\logindao.java package com.beingjavaguys.dao.login; import com.beingjavaguys.models.login.users; public interface logindao { users findbyusername(string username); } \src\main\java\com\beingjavaguys\dao\login\logindaoimpl.java package com.beingjavaguys.dao.login; import org.hibernate.session; import org.hibernate.sessionfactory; import org.hibernate.transaction; import org.springframework.beans.factory.annotation.autowired; import org.springframework.stereotype.repository; import com.beingjavaguys.models.login.users; @repository("logindao") public class logindaoimpl implements logindao{ @autowired sessionfactory sessionfactory; session session = null; transaction tx = null; @override public users findbyusername(string username) { session = sessionfactory.opensession(); tx = session.gettransaction(); session.begintransaction(); users user = (users) session.load(users.class, new string(username)); tx.commit(); return user; } } \src\main\java\com\beingjavaguys\service\login\loginserviceimpl.java package com.beingjavaguys.service.login; import java.util.arraylist; import java.util.hashset; import java.util.list; import java.util.set; import org.springframework.beans.factory.annotation.autowired; import org.springframework.security.core.grantedauthority; import org.springframework.security.core.authority.simplegrantedauthority; import org.springframework.security.core.userdetails.user; import org.springframework.security.core.userdetails.userdetails; import org.springframework.security.core.userdetails.userdetailsservice; import org.springframework.security.core.userdetails.usernamenotfoundexception; import org.springframework.stereotype.service; import com.beingjavaguys.dao.login.logindao; import com.beingjavaguys.models.login.userrole; import com.beingjavaguys.models.login.users; @service("loginservice") public class loginserviceimpl implements userdetailsservice { @autowired logindao logindao; @override public userdetails loaduserbyusername(string username) throws usernamenotfoundexception { users user = logindao.findbyusername(username); list authorities = builduserauthority(user .getuserrole()); return builduserforauthentication(user, authorities); } private user builduserforauthentication(users user, list authorities) { return new user(user.getusername(), user.getpassword(), user.isenabled(), true, true, true, authorities); } private list builduserauthority(set userroles) { set setauths = new hashset(); // build user's authorities for (userrole userrole : userroles) { setauths.add(new simplegrantedauthority(userrole.getrole())); } list result = new arraylist( setauths); return result; } } front end layer files login form \src\main\webapp\web-inf\pages\login.jsp <%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> login | beingjavaguys.com





please enter your username and password to login !
${message}
username:
password:
\src\main\webapp\web-inf\pages\home.jsp <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> home page | beingjavaguys.com



default logged in user page !!!

\src\main\webapp\web-inf\pages\admin.jsp <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> admin profile page | beingjavaguys.com



admin profile page !!!

\src\main\webapp\web-inf\pages\user.jsp <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> user profile page | beingjavaguys.com



user profile page !!!

\src\main\webapp\web-inf\pages\403.jsp <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> access denied | beingjavaguys.com



access denied for user : ${username}

how to run the application once you are donw with adding all required file to the project, simple run the application on server and hit following url: http://localhost:8080/sp_sc_hibernate/user it will redirect you to login page (http://localhost:8080/sp_sc_hibernate/login) enter the user credentials "user"/"user@123", and you will get your requested page after a success login: now try to see admin page, hit url http://localhost:8080/sp_sc_hibernate/admin now you will get a access denied error, because "user" is not authorized to see "/admin" pages. that's all for now in, spring security with hibernate with maven. more details on : spring security authentication and authorization download complete project : download link thanks for reading ! being java guys team download "spring security with hibernate example project" from "skydrive" facebook twitter google+ stumble digg read more thursday, 14 august 2014 spring 4 restful web services with hibernate 4 example using maven – server application nagesh chauhan 12:34 hibernate, spring-mvc, web-services 32 comments ask a question spring 4 restful web services with hibernate 4 example using maven – server application in our previous discussions we came across several spring related topics. in this particular blog we will see how to create spring restful web services with hibernate using maven. we will create and build the project with maven and hibernate 4 will be used in data layer. to get started simply create a simple web application with maven and import it in eclipse. if you are new to maven please go through the link below. more details on : dynamic web project with maven and import it in eclipse now we have a skeleton maven project imported to eclipse, lets add all required java and configuration files to it as shown in the rest part of the tutorial. database setup here us mysql script to create a simple database and table structure to be used in our application, simply paste the script in query editor and run to make a db skeleton. /*!40101 set @old_character_set_client=@@character_set_client */; /*!40101 set names utf8 */; /*!40014 set foreign_key_checks=0 */; -- dumping database structure for employee_db create database if not exists `employee_db` /*!40100 default character set latin1 */; use `employee_db`; -- dumping structure for table employee_db.employee create table if not exists `employee` ( `id` bigint(20) not null auto_increment, `first_name` varchar(45) default null, `last_name` varchar(45) default null, `email` varchar(45) default null, `phone` varchar(45) default null, primary key (`id`) ) engine=innodb auto_increment=3 default charset=latin1; -- dumping data for table employee_db.employee: ~1 rows (approximately) /*!40000 alter table `employee` disable keys */; insert into `employee` (`id`, `first_name`, `last_name`, `email`, `phone`) values (2, 'hoston', 'lindey', 'hl@gmail.com', '90908989899'); /*!40000 alter table `employee` enable keys */; /*!40014 set foreign_key_checks=1 */; /*!40101 set character_set_client=@old_character_set_client */; dependencies required to make spring restful web services with hibernate pom.xml 4.0.0 com.beingjavaguys.sample springrestcrud war 1.0-snapshot springrestcrud maven webapp http://maven.apache.org 4.0.5.release 4.3.5.final 1.2.17 1.7 springrestcrud ${pom.artifactid} maven-compiler-plugin ${jdk.version} ${jdk.version} log4j log4j ${log4j.version} org.springframework spring-orm ${spring.version} org.springframework spring-jdbc ${spring.version} org.springframework spring-jdbc ${spring.version} org.springframework spring-web ${spring.version} org.springframework spring-webmvc ${spring.version} jstl jstl 1.2 com.google.code.gson gson 2.2.2 mysql mysql-connector-java 5.1.6 org.codehaus.jackson jackson-mapper-asl 1.9.10 org.hibernate hibernate-entitymanager ${hibernate.version} \src\main\webapp\web-inf\web.xml we need to make an spring entry to web.xml, this will tell the container that all upcoming requests will be served by spring framework itself as per the configuration. sample spring maven project mvc-dispatcher org.springframework.web.servlet.dispatcherservlet contextconfiglocation /web-inf/spring-config.xml 1 mvc-dispatcher / \src\main\webapp\web-inf\spring-config.xml this is simple spring configuration file, we have added entry for base-package her to search and find controller classes with annotations. we defined two beans here for service and dao layer that we will see in details shortly. rest is hibernate configurations and a datasource bean to connect with database. more details on : spring hibernate integration com.beingjavaguys.model.employee org.hibernate.dialect.mysql5dialect ${hibernate.show_sql} \src\main\java\com\beingjavaguys\controller\restcontroller.java this is simple spring mvc controller with annotations, we have added all general purpose methods here those method will accept a rest request in json form and will return a json response. the methods are self explanatory we have used @controller annotation to point incoming requests to this class, and @requestmapping annotation to point incoming requests to appropriate methods. @requestbody annotation is used to accept data with request in json form and @responsebody is used to return json as response to incoming request. package com.beingjavaguys.controller; import java.util.list; import org.apache.log4j.logger; import com.beingjavaguys.model.status; import org.springframework.beans.factory.annotation.autowired; import org.springframework.http.mediatype; import org.springframework.stereotype.controller; import org.springframework.web.bind.annotation.pathvariable; import org.springframework.web.bind.annotation.requestbody; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestmethod; import org.springframework.web.bind.annotation.responsebody; import com.beingjavaguys.model.employee; import com.beingjavaguys.services.dataservices; @controller @requestmapping("/employee") public class restcontroller { @autowired dataservices dataservices; static final logger logger = logger.getlogger(restcontroller.class); /* submit form in spring restful services */ @requestmapping(value = "/create", method = requestmethod.post, consumes = mediatype.application_json_value) public @responsebody status addemployee(@requestbody employee employee) { try { dataservices.addentity(employee); return new status(1, "employee added successfully !"); } catch (exception e) { // e.printstacktrace(); return new status(0, e.tostring()); } } /* ger a single objct in json form in spring rest services */ @requestmapping(value = "/{id}", method = requestmethod.get) public @responsebody employee getemployee(@pathvariable("id") long id) { employee employee = null; try { employee = dataservices.getentitybyid(id); } catch (exception e) { e.printstacktrace(); } return employee; } /* getting list of objects in json format in spring restful services */ @requestmapping(value = "/list", method = requestmethod.get) public @responsebody list getemployee() { list employeelist = null; try { employeelist = dataservices.getentitylist(); } catch (exception e) { e.printstacktrace(); } return employeelist; } /* delete an object from db in spring restful services */ @requestmapping(value = "delete/{id}", method = requestmethod.get) public @responsebody status deleteemployee(@pathvariable("id") long id) { try { dataservices.deleteentity(id); return new status(1, "employee deleted successfully !"); } catch (exception e) { return new status(0, e.tostring()); } } } more details on : spring json – output json in spring application model classes \springrestcrud\src\main\java\com\beingjavaguys\model\employee.java this is simple pojo to represent employee entity in our application, we will be dealing with employee entity to save, retrieve and delete data using spring restful web services. we have annotated the class with hibernate annotations to make hibernate aware of the entity. package com.beingjavaguys.model; import java.io.serializable; import javax.persistence.column; import javax.persistence.entity; import javax.persistence.generatedvalue; import javax.persistence.id; import javax.persistence.table; import org.codehaus.jackson.annotate.jsonignoreproperties; @entity @table(name = "employee") @jsonignoreproperties({"hibernatelazyinitializer", "handler"}) public class employee implements serializable { private static final long serialversionuid = 1l; @id @generatedvalue @column(name = "id") private long id; @column(name = "first_name") private string firstname; @column(name = "last_name") private string lastname; @column(name = "email") private string email; @column(name = "phone") private string phone; public long getid() { return id; } public void setid(long id) { this.id = id; } public string getfirstname() { return firstname; } public void setfirstname(string firstname) { this.firstname = firstname; } public string getlastname() { return lastname; } public void setlastname(string lastname) { this.lastname = lastname; } public string getemail() { return email; } public void setemail(string email) { this.email = email; } public string getphone() { return phone; } public void setphone(string phone) { this.phone = phone; } } don’t forget to add @jsonignoreproperties({"hibernatelazyinitializer", "handler"}) annotation to class, this is used to resolve hibernate and json conflict. \src\main\java\com\beingjavaguys\model\status.java this is another pojo to represent conditional status and error messages in form of json, this comes handy in case of sending status response to requests if needed. package com.beingjavaguys.model; public class status { private int code; private string message; public status() { } public status(int code, string message) { this.code = code; this.message = message; } public int getcode() { return code; } public void setcode(int code) { this.code = code; } public string getmessage() { return message; } public void setmessage(string message) { this.message = message; } } data layer with spring and hibernate below are simple service and dao classes and interfaces to make a two tier data layer between spring and hibernate. more details on : spring hibernate integration \src\main\java\com\beingjavaguys\dao\datadao.java package com.beingjavaguys.dao; import java.util.list; import com.beingjavaguys.model.employee; public interface datadao { public boolean addentity(employee employee) throws exception; public employee getentitybyid(long id) throws exception; public list getentitylist() throws exception; public boolean deleteentity(long id) throws exception; } \src\main\java\com\beingjavaguys\dao\datadaoimpl.java package com.beingjavaguys.dao; import java.util.list; import org.hibernate.session; import org.hibernate.sessionfactory; import org.hibernate.transaction; import org.springframework.beans.factory.annotation.autowired; import com.beingjavaguys.model.employee; public class datadaoimpl implements datadao { @autowired sessionfactory sessionfactory; session session = null; transaction tx = null; @override public boolean addentity(employee employee) throws exception { session = sessionfactory.opensession(); tx = session.begintransaction(); session.save(employee); tx.commit(); session.close(); return false; } @override public employee getentitybyid(long id) throws exception { session = sessionfactory.opensession(); employee employee = (employee) session.load(employee.class, new long(id)); tx = session.gettransaction(); session.begintransaction(); tx.commit(); return employee; } @suppresswarnings("unchecked") @override public list getentitylist() throws exception { session = sessionfactory.opensession(); tx = session.begintransaction(); list employeelist = session.createcriteria(employee.class) .list(); tx.commit(); session.close(); return employeelist; } @override public boolean deleteentity(long id) throws exception { session = sessionfactory.opensession(); object o = session.load(employee.class, id); tx = session.gettransaction(); session.begintransaction(); session.delete(o); tx.commit(); return false; } } \src\main\java\com\beingjavaguys\services\dataservices.java package com.beingjavaguys.services; import java.util.list; import com.beingjavaguys.model.employee; public interface dataservices { public boolean addentity(employee employee) throws exception; public employee getentitybyid(long id) throws exception; public list getentitylist() throws exception; public boolean deleteentity(long id) throws exception; } \src\main\java\com\beingjavaguys\services\dataservicesimpl.java package com.beingjavaguys.services; import java.util.list; import org.springframework.beans.factory.annotation.autowired; import com.beingjavaguys.dao.datadao; import com.beingjavaguys.model.employee; public class dataservicesimpl implements dataservices { @autowired datadao datadao; @override public boolean addentity(employee employee) throws exception { return datadao.addentity(employee); } @override public employee getentitybyid(long id) throws exception { return datadao.getentitybyid(id); } @override public list getentitylist() throws exception { return datadao.getentitylist(); } @override public boolean deleteentity(long id) throws exception { return datadao.deleteentity(id); } } in this particular article we came across "spring 4 restful web services with hibernate 4 example using maven", in our next discussion we will see how to create a client application in spring to consume spring restful services. download complete project : download link note : in case you want to test the application with some dummy data and without using any client application, you can do that using chrome's postman - rest client. make sure to set content-type: application/json when sending form data in json format to the service. thanks for reading ! being java guys team download "spring 4 restful web services with hibernate 4 example" from "skydrive" facebook twitter google+ stumble digg read more older posts → home subscribe to: posts (atom) write an article, we will publish it here in your name fresher jobs and walkin - india --> --> like us on facebook search tutorials search tutorials --> link add end --> link add end --> --> like us on google+ contact email: neel4soft@gmail.com skype: neel4soft copyright © java, struts 2, spring, hibernate, solr, mahout and hadoop tutorials tips and tricks | www.t20worldcup2020.com | powered by blogger design by mythemeshop | blogger theme by newbloggerthemes.com | hip hop beats. back to top ↑


Here you find all texts from your page as Google (googlebot) and others search engines seen it.

Words density analysis:

Numbers of all words: 8549

- 0.04% (3)
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"> - 0.04% (3)
- 0.04% (3)
- 0.04% (3)
${jdk.version}${jdk.version} - 0.04% (3)
maven-compiler-plugin - 0.04% (3)
- 0.04% (3)
${pom.artifactid} - 0.04% (3)
download complete - 0.04% (3)
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd - 0.04% (3)
project : - 0.04% (3)
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd - 0.04% (3)
git hub - 0.04% (3)
xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc" - 0.04% (3)
hibernate configuration - 0.04% (3)
import javax.persistence.id; - 0.04% (3)
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://maven.apache.org/pom/4.0.0 - 0.04% (3)
http://maven.apache.org/maven-v4_0_0.xsd"> 4.0.0 - 0.04% (3)
war 1.0-snapshot - 0.04% (3)
webapp http://maven.apache.org - 0.04% (3)
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns:context="http://www.springframework.org/schema/context" - 0.04% (3)
version="1.0" encoding="utf-8"?> - 0.04% (3)
1.2.17 1.7 - 0.04% (3)
import javax.persistence.entity; - 0.04% (3)
- 0.04% (3)
${pom.artifactid} - 0.04% (3)
maven-compiler-plugin - 0.04% (3)
${jdk.version} - 0.04% (3)
${jdk.version}
- 0.04% (3)
charset=latin1; -- - 0.04% (3)
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util - 0.04% (3)
import org.springframework.web.bind.annotation.requestmapping; - 0.04% (3)
the session - 0.04% (3)
on the - 0.04% (3)
is used - 0.04% (3)
question in - 0.04% (3)
caching is - 0.04% (3)
be served - 0.04% (3)
but the - 0.04% (3)
consumer consumer - 0.04% (3)
have an - 0.04% (3)
- 0.04% (3)
as well, - 0.04% (3)
database and - 0.04% (3)
sessionfactory.opensession(); tx - 0.04% (3)
session is - 0.04% (3)
cache is - 0.04% (3)
body of - 0.04% (3)
5); list.foreach(i - 0.04% (3)
maven webapp - 0.04% (3)
what are - 0.04% (3)
system.out.println("****created session - 0.04% (3)
dependencies required - 0.04% (3)
xmlns="http://maven.apache.org/pom/4.0.0" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" - 0.04% (3)
xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> - 0.04% (3)
4.0.0 com.beingjavaguys.sample - 0.04% (3)
of functional - 0.04% (3)
tx.commit(); return - 0.04% (3)
be returned - 0.04% (3)
log4j log4j - 0.04% (3)
${log4j.version} - 0.04% (3)
create an - 0.04% (3)
spring-jdbc ${spring.version} - 0.04% (3)
can pass - 0.04% (3)
application in - 0.04% (3)
system.out.print((i + - 0.04% (3)
system.out.println("****closed session - 0.04% (3)
this.phone = - 0.04% (3)
to override - 0.04% (3)
a method - 0.04% (3)
// todo - 0.04% (3)
stub } - 0.04% (3)
does not - 0.04% (3)
@table(name = - 0.04% (3)
where we - 0.04% (3)
type of - 0.04% (3)
javax.persistence.id; import - 0.04% (3)
javax.persistence.entity; import - 0.04% (3)
void b() - 0.04% (3)
javax.persistence.column; import - 0.04% (3)
phone) { - 0.04% (3)
{ @override - 0.04% (3)
static method - 0.04% (3)
message; } - 0.04% (3)
can have - 0.04% (3)
requestmethod.get) public - 0.04% (3)
are the - 0.04% (3)
any java - 0.04% (3)
in form - 0.04% (3)
employeelist = - 0.04% (3)
import org.springframework.stereotype.controller; - 0.04% (3)
written and - 0.04% (3)
to represent - 0.04% (3)
java program - 0.04% (3)
a number - 0.04% (3)
private int - 0.04% (3)
pass a - 0.04% (3)
anonymous function - 0.04% (3)
form of - 0.04% (3)
came across - 0.04% (3)
as per - 0.04% (3)
the concept - 0.04% (3)
code and - 0.04% (3)
call made - 0.04% (3)
json response - 0.04% (3)
third request - 0.04% (3)
came for - 0.04% (3)
was present - 0.04% (3)
db call - 0.04% (3)
- authentication - 0.04% (3)
team download - 0.04% (3)
caching works - 0.04% (3)
made and - 0.04% (3)
entity served - 0.04% (3)
cache, the - 0.04% (3)
how evict() - 0.04% (3)
cache so - 0.04% (3)
and clear() - 0.04% (3)
--> --> - 0.04% (3)
what is - 0.04% (3)
http://www.springframework.org/schema/util/spring-util-3.2.xsd http://www.springframework.org/schema/context - 0.04% (3)
system.out.println(employee.getfirstname()); employee - 0.04% (3)
removed employee - 0.04% (3)
new to - 0.04% (3)
example using - 0.04% (3)
article we - 0.04% (3)
and how - 0.04% (3)
all the - 0.04% (3)
json format - 0.04% (3)
: download - 0.04% (3)
and entity - 0.04% (3)
present on - 0.04% (3)
on server - 0.04% (3)
the token - 0.04% (3)
users and - 0.04% (3)
token is - 0.04% (3)
most of - 0.04% (3)
with oauth2 - 0.04% (3)
entity, this - 0.04% (3)
) engine=innodb - 0.04% (3)
a user - 0.04% (3)
complete project - 0.04% (3)
time the - 0.04% (3)
system.out.println(employee.getfirstname()); transaction.commit(); - 0.04% (3)
/*!40014 set - 0.04% (3)
sessionfactory.opensession(); system.out.println("****created - 0.04% (3)
entity was - 0.04% (3)
integrate spring - 0.04% (3)
eddy ****closed - 0.04% (3)
message) { - 0.02% (2)
"skydrive" facebook - 0.02% (2)
package com.beingjavaguys.models.login; - 0.02% (2)
username); } - 0.02% (2)
}) public - 0.02% (2)
http://www.springframework.org/schema/context/spring-context-3.2.xsd"> return email; - 0.02% (2)
email) { - 0.02% (2)
@requestparam(value = - 0.02% (2)
void setemail(string - 0.02% (2)
package com.beingjavaguys.model; - 0.02% (2)
article, we - 0.02% (2)
getphone() { - 0.02% (2)
in your - 0.02% (2)
return phone; - 0.02% (2)
void setphone(string - 0.02% (2)
link add - 0.02% (2)
--> like - 0.02% (2)
base-package="com.beingjavaguys" /> - 0.02% (2)
""; if - 0.02% (2)
null) { - 0.02% (2)
this.code = - 0.02% (2)
and dao - 0.02% (2)
application with - 0.02% (2)
id="persistenceexceptiontranslationpostprocessor" class="org.springframework.dao.annotation.persistenceexceptiontranslationpostprocessor" - 0.02% (2)
id="sessionfactory" class="org.springframework.orm.hibernate4.localsessionfactorybean"> - 0.02% (2)
employee; } - 0.02% (2)
- 0.02% (2)
springsecurityfilterchain org.springframework.web.filter.delegatingfilterproxy - 0.02% (2)
- 0.02% (2)
script in - 0.02% (2)
dumping database - 0.02% (2)
the application. - 0.02% (2)
spring entry - 0.02% (2)
to web.xml, - 0.02% (2)
tell the - 0.02% (2)
container that - 0.02% (2)
framework itself - 0.02% (2)
the configuration. - 0.02% (2)
security in - 0.02% (2)
\src\main\webapp\web-inf\spring-config.xml this - 0.02% (2)
\src\main\webapp\web-inf\web.xml we - 0.02% (2)
file, we - 0.02% (2)
entry for - 0.02% (2)
to search - 0.02% (2)
and find - 0.02% (2)
classes with - 0.02% (2)
annotations. we - 0.02% (2)
beans here - 0.02% (2)
for hibernate - 0.02% (2)
make an - 0.02% (2)
mysql mysql-connector-java - 0.02% (2)
database if - 0.02% (2)
`user_roles` ( - 0.02% (2)
default character - 0.02% (2)
set latin1 - 0.02% (2)
*/; use - 0.02% (2)
`username` varchar(45) - 0.02% (2)
(`username`) ) - 0.02% (2)
table `users` - 0.02% (2)
*/; -- - 0.02% (2)
key (`username`) - 0.02% (2)
jstl - 0.02% (2)
table `user_roles` - 0.02% (2)
set foreign_key_checks=1 - 0.02% (2)
set character_set_client=@old_character_set_client - 0.02% (2)
org.hibernate - 0.02% (2)
hibernate-entitymanager ${hibernate.version} - 0.02% (2)
spring-orm ${spring.version} - 0.02% (2)
spring-security-web ${spring.security.version} - 0.02% (2)
org.springframework.security spring-security-config - 0.02% (2)
the expression - 0.02% (2)
ref="tokenservices" /> - 0.02% (2)
three times - 0.02% (2)
secure restful - 0.02% (2)
integrate neo4j - 0.02% (2)
(graph db) - 0.02% (2)
– neo4j - 0.02% (2)
(neo4j + - 0.02% (2)
java) facebook - 0.02% (2)
securing restful - 0.02% (2)
kind of - 0.02% (2)
using spring - 0.02% (2)
annotation (spring - 0.02% (2)
will use - 0.02% (2)
authenticated users - 0.02% (2)
a valid - 0.02% (2)
from oauth - 0.02% (2)
token and - 0.02% (2)
the request - 0.02% (2)
returns a - 0.02% (2)
new token - 0.02% (2)
+ json) - 0.02% (2)
with @responsebody - 0.02% (2)
to secure - 0.02% (2)
can clear - 0.02% (2)
requested for - 0.02% (2)
the employee - 0.02% (2)
we look - 0.02% (2)
into how - 0.02% (2)
clear() works - 0.02% (2)
in hibernate. - 0.02% (2)
to know - 0.02% (2)
articles we - 0.02% (2)
example spring - 0.02% (2)
second level - 0.02% (2)
caching and - 0.02% (2)
query caching - 0.02% (2)
be found - 0.02% (2)
it from - 0.02% (2)
posts spring - 0.02% (2)
example with - 0.02% (2)
database credentials - 0.02% (2)
new access - 0.02% (2)
more on - 0.02% (2)
--> a token - 0.02% (2)
com.google.code.gson - 0.02% (2)
gson 2.2.2 - 0.02% (2)
org.codehaus.jackson jackson-mapper-asl - 0.02% (2)
1.9.10
- 0.02% (2)
thing in - 0.02% (2)
2, spring, - 0.02% (2)
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.2.xsd - 0.02% (2)
org.springframework.security spring-security-web - 0.02% (2)
if you - 0.02% (2)
enabled="false" /> - 0.02% (2)
class="org.springframework.security.oauth2.provider.error.oauth2authenticationentrypoint"> xmlns="http://www.springframework.org/schema/security"> user defined - 0.02% (2)
ref="clientdetails" /> - 0.02% (2)
token based - 0.02% (2)
spring-security-config ${spring.security.version} - 0.02% (2)
log4j --> - 0.02% (2)
import org.springframework.web.bind.annotation.requestmethod; - 0.02% (2)
structure to - 0.02% (2)
import org.springframework.web.bind.annotation.responsebody; - 0.02% (2)
restcontroller { - 0.02% (2)
@autowired dataservice - 0.02% (2)
list() { - 0.02% (2)
get request - 0.02% (2)
and it - 0.02% (2)
will return - 0.02% (2)
simple service - 0.02% (2)
returned in - 0.02% (2)
required to - 0.02% (2)
on spring - 0.02% (2)
dataservice { - 0.02% (2)
getuserlist(); } - 0.02% (2)
have created - 0.02% (2)
and added - 0.02% (2)
import java.util.arraylist; - 0.02% (2)
import org.springframework.stereotype.service; - 0.02% (2)
implements dataservice - 0.02% (2)
end --> - 0.02% (2)

One word

Two words phrases

Three words phrases

spring - 4.02% (344)
use - 3.18% (272)
java - 3.03% (259)
the - 2.87% (245)
user - 2.76% (236)
name - 2.26% (193)
int - 2.15% (184)
auth - 1.99% (170)
and - 1.98% (169)
employee - 1.75% (150)
framework - 1.71% (146)
uri - 1.63% (139)
session - 1.52% (130)
security - 1.49% (127)
fact - 1.43% (122)
for - 1.42% (121)
http - 1.39% (119)
app - 1.37% (117)
import - 1.31% (112)
data - 1.29% (110)
hibernate - 1.26% (108)
public - 1.25% (107)
list - 1.23% (105)
web - 1.22% (104)
class - 1.16% (99)
service - 1.11% (95)
get - 1.11% (95)
end - 1.08% (92)
being - 1.06% (91)
per - 1.05% (90)
bean - 1.02% (87)
guys - 0.98% (84)
this - 0.96% (82)
with - 0.95% (81)
not - 0.88% (75)
oauth - 0.8% (68)
request - 0.8% (68)
ger - 0.8% (68)
impl - 0.77% (66)
her - 0.76% (65)
token - 0.74% (63)
entity - 0.73% (62)
one - 0.7% (60)
value - 0.69% (59)
string - 0.67% (57)
return - 0.66% (56)
set - 0.64% (55)
services - 0.64% (55)
method - 0.63% (54)
can - 0.63% (54)
authentic - 0.62% (53)
login - 0.62% (53)
our - 0.58% (50)
rest - 0.56% (48)
context - 0.56% (48)
client - 0.55% (47)
first - 0.54% (46)
servlet - 0.54% (46)
mvc - 0.54% (46)
model - 0.53% (45)
username - 0.53% (45)
lambda - 0.51% (44)
interface - 0.51% (44)
authentication - 0.51% (44)
users - 0.5% (43)
form - 0.5% (43)
beans - 0.5% (43)
url - 0.49% (42)
filter - 0.48% (41)
maven - 0.47% (40)
dao - 0.47% (40)
pass - 0.47% (40)
code - 0.46% (39)
type - 0.46% (39)
that - 0.46% (39)
will - 0.46% (39)
source - 0.46% (39)
cache - 0.44% (38)
access - 0.43% (37)
function - 0.43% (37)
java. - 0.43% (37)
from - 0.43% (37)
expression - 0.42% (36)
here - 0.42% (36)
have - 0.42% (36)
integer - 0.41% (35)
--> - 0.41% (35)
system - 0.41% (35)
void - 0.41% (35)
annotation - 0.41% (35)
are - 0.41% (35)
- 0.4% (34)
new - 0.4% (34)
- 0.4% (34)
transaction - 0.39% (33)
details - 0.39% (33)
add - 0.39% (33)
create - 0.37% (32)
sessionfactory - 0.37% (32)
all - 0.37% (32)
hibernate. - 0.35% (30)
example - 0.35% (30)
table - 0.35% (30)
database - 0.34% (29)
except - 0.33% (28)
employee0_ - 0.33% (28)
application - 0.33% (28)
controller - 0.32% (27)
exception - 0.32% (27)
password - 0.32% (27)
body - 0.32% (27)
- 0.11% (9)
level cache - 0.11% (9)
is not - 0.11% (9)
java.util.list; import - 0.11% (9)
configuration file - 0.11% (9)
= (employee) - 0.09% (8)
id) throws - 0.09% (8)
object is - 0.09% (8)
throws exception; - 0.09% (8)
name; } - 0.09% (8)
programming language - 0.09% (8)
-- dumping - 0.09% (8)
will be - 0.09% (8)
with java - 0.09% (8)
- 0.05% (4)
public employee - 0.05% (4)
getentitybyid(long id) - 0.05% (4)
maven project - 0.05% (4)
like this: - 0.05% (4)
with spring - 0.05% (4)
type="submit" value="log - 0.05% (4)
method="post">
value="j_spring_security_logout" /> - 0.05% (4)
will get - 0.05% (4)
profile page - 0.05% (4)
the user - 0.05% (4)
something like - 0.05% (4)
have added - 0.05% (4)
/> - 0.05% (4)
variable capture - 0.05% (4)
- 0.05% (4)
var="logouturl" value="j_spring_security_logout" - 0.05% (4)
value="${_csrf.token}" /> - 0.05% (4)
type="hidden" name="${_csrf.parametername}" - 0.05% (4)
you will - 0.05% (4)
/> spring hibernate - 0.05% (4)
for now - 0.05% (4)
value="log out" - 0.05% (4)
name="${_csrf.parametername}" value="${_csrf.token}" - 0.05% (4)
deleteentity(long id) - 0.05% (4)
- 0.05% (4)
for reading - 0.05% (4)
com.beingjavaguys.services; import - 0.05% (4)
employee0_.id=? eddy - 0.05% (4)
} catch - 0.05% (4)
from employee - 0.05% (4)
org.hibernate.session; import - 0.05% (4)
xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" - 0.05% (4)
*/ public - 0.05% (4)
catch (exception - 0.05% (4)
{ this.user - 0.05% (4)
web project - 0.05% (4)
import org.hibernate.sessionfactory; - 0.05% (4)
an open - 0.05% (4)
import org.hibernate.session; - 0.05% (4)
org.hibernate.transaction; import - 0.05% (4)
public @responsebody - 0.05% (4)
*/ @requestmapping(value - 0.05% (4)
restful services - 0.05% (4)
action="${logouturl}" method="post"> - 0.05% (4)
this particular - 0.05% (4)
import org.hibernate.transaction; - 0.05% (4)
spring configuration - 0.05% (4)
role; } - 0.05% (4)
email; } - 0.05% (4)
spring security, - 0.05% (4)
how first - 0.05% (4)
annotation to - 0.05% (4)
as phone5_0_0_ - 0.05% (4)
for the - 0.05% (4)
and do - 0.05% (4)
data from - 0.05% (4)
for spring - 0.05% (4)
query is - 0.05% (4)
} return - 0.05% (4)
org.hibernate.sessionfactory; import - 0.05% (4)
and import - 0.05% (4)
of passing - 0.05% (4)
select employee0_.id - 0.05% (4)
as id1_0_0_, - 0.05% (4)
// way - 0.05% (4)
passing existing - 0.05% (4)
method as - 0.05% (4)
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd - 0.05% (4)
dosomething(integer i) - 0.05% (4)
= requestmethod.get) - 0.05% (4)
@author nagesh.chauhan(neel4soft@gmail.com) - 0.05% (4)
employee0_.email as - 0.05% (4)
email2_0_0_, employee0_.first_name - 0.05% (4)
= session.begintransaction(); - 0.05% (4)
(exception e) - 0.05% (4)
services */ - 0.05% (4)
as first_na3_0_0_, - 0.05% (4)
?> employee0_.last_name as - 0.05% (4)
to create - 0.05% (4)
last_nam4_0_0_, employee0_.phone - 0.05% (4)
sample spring - 0.04% (3)
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> - 0.04% (3)
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/javaee - 0.04% (3)
maven project
- 0.04% (3)
@entity @table(name - 0.04% (3)
of users - 0.04% (3)
this article - 0.04% (3)
all required - 0.04% (3)
requests to - 0.04% (3)
import javax.persistence.table; - 0.04% (3)
org.springframework spring-webmvc - 0.04% (3)
spring-web ${spring.version} - 0.04% (3)
org.springframework spring-jdbc - 0.04% (3)
to configure - 0.04% (3)
added a - 0.04% (3)
upcoming requests - 0.04% (3)
to use - 0.04% (3)
that all - 0.04% (3)
= email; - 0.04% (3)
import com.beingjavaguys.models.user; - 0.04% (3)
security configuration - 0.04% (3)
this.id = - 0.04% (3)
string phone) - 0.04% (3)
false) private - 0.04% (3)
user; } - 0.04% (3)
a single - 0.04% (3)
class user - 0.04% (3)
mvc-dispatcher / - 0.04% (3)
todo auto-generated - 0.04% (3)
configurations and - 0.04% (3)
encoding="utf-8"?> xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util" - 0.04% (3)
xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemalocation="http://www.springframework.org/schema/mvc - 0.04% (3)
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd http://www.springframework.org/schema/beans - 0.04% (3)
- 0.04% (3)
entry to - 0.04% (3)
false, length - 0.04% (3)
- 0.04% (3)
this.email = - 0.04% (3)
by spring - 0.04% (3)
requests will - 0.04% (3)
!!! be accessed - 0.04% (3)
= phone; - 0.04% (3)
bean to - 0.04% (3)
mvc-dispatcher - 0.04% (3)
this will - 0.04% (3)
- 0.04% (3)
xsi:schemalocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd - 0.04% (3)
database. more - 0.04% (3)
*/; insert - 0.04% (3)
- 0.04% (3)
- 0.04% (3)
insert into - 0.04% (3)
log4j - 0.04% (3)
log4j ${log4j.version} - 0.04% (3)
(approximately) /*!40000 - 0.04% (3)
data for - 0.04% (3)
default charset=latin1; - 0.04% (3)
org.springframework spring-web - 0.04% (3)
null, primary - 0.04% (3)
varchar(45) not - 0.04% (3)
spring-webmvc ${spring.version} - 0.04% (3)
enable keys - 0.04% (3)
user = - 0.04% (3)
/> import javax.persistence.column; - 0.04% (3)
disable keys - 0.04% (3)
we defined - 0.04% (3)
from db - 0.04% (3)
rows (approximately) - 0.04% (3)
username = - 0.04% (3)
dumping structure - 0.04% (3)
{ private - 0.04% (3)
/> - 0.04% (3)
session.gettransaction(); session.begintransaction(); - 0.04% (3)
primary key - 0.04% (3)
- 0.04% (3)
--> table if - 0.04% (3)
`users` ( - 0.04% (3)
configure spring - 0.04% (3)
*/; /*!40014 - 0.04% (3)
/> */; /*!40101 - 0.04% (3)
/>
} public void - 0.22% (19)
we have a - 0.16% (14)
restful web services - 0.15% (13)
org.springframework - 0.13% (11)
} public string - 0.12% (10)
spring security with - 0.12% (10)
${spring.version}
- 0.12% (10)
web services with - 0.12% (10)
from the cache - 0.11% (9)
import java.util.list; import - 0.11% (9)
first level cache - 0.11% (9)
java 8 lambda - 0.11% (9)
name; } public - 0.09% (8)
authentication and authorization - 0.09% (8)
we will see - 0.09% (8)
/> services with hibernate - 0.09% (8)
throws exception { - 0.09% (8)
id) throws exception - 0.09% (8)
this is simple - 0.09% (8)
employee = (employee) - 0.09% (8)
the object is - 0.09% (8)
arrays.aslist(1, 2, 3, - 0.08% (7)
list list = - 0.08% (7)
details on : - 0.08% (7)
security with hibernate - 0.08% (7)
session = sessionfactory.opensession(); - 0.08% (7)
more details on - 0.08% (7)
= arrays.aslist(1, 2, - 0.08% (7)
list = arrays.aslist(1, - 0.08% (7)
3, 4, 5); - 0.08% (7)
spring security and - 0.08% (7)
first level caching - 0.08% (7)
nagesh.chauhan * */ - 0.07% (6)
with hibernate 4 - 0.07% (6)
session1.load(employee.class, 1l); system.out.println(employee.getfirstname()); - 0.07% (6)
comments ask a - 0.07% (6)
in json form - 0.07% (6)
/** * @author - 0.07% (6)
@author nagesh.chauhan * - 0.07% (6)
* @author nagesh.chauhan - 0.07% (6)
/*!40000 alter table - 0.07% (6)
(employee) session1.load(employee.class, 1l); - 0.07% (6)
import org.springframework.beans.factory.annotation.autowired; import - 0.07% (6)
works in hibernate - 0.07% (6)
digg read more - 0.07% (6)
throws exception; public - 0.07% (6)
twitter google+ stumble - 0.07% (6)
stumble digg read - 0.07% (6)
google+ stumble digg - 0.07% (6)
ask a question - 0.07% (6)
spring 4 restful - 0.07% (6)
facebook twitter google+ - 0.07% (6)
4 restful web - 0.07% (6)
public static void - 0.07% (6)
} @override public - 0.07% (6)
taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> - 0.06% (5)
if not exists - 0.06% (5)
that is stored - 0.06% (5)
- 0.06% (5)
| beingjavaguys.com - 0.06% (5)
prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> - 0.06% (5)
uri="http://java.sun.com/jsp/jstl/core"%> - 0.06% (5)
{ session = - 0.06% (5)
a list of - 0.06% (5)
/>
- 0.06% (5)
-- dumping data - 0.06% (5)
and authorization example - 0.06% (5)
will see how - 0.06% (5)
- 0.05% (4)
type="submit" value="log out" - 0.05% (4)
action="${logouturl}" method="post"> value="log out" /> - 0.05% (4)
for reading ! - 0.05% (4)
this is where - 0.05% (4)
@author nagesh.chauhan(neel4soft@gmail.com) --> - 0.05% (4)
link add - 0.02% (2)
--> like us - 0.02% (2)
: download link - 0.02% (2)
throws exception; } - 0.02% (2)
employee) throws exception; - 0.02% (2)
tx.commit(); session.close(); return - 0.02% (2)
@override public employee - 0.02% (2)
return false; } - 0.02% (2)
tx = session.begintransaction(); - 0.02% (2)
transaction tx = - 0.02% (2)
pojo to represent - 0.02% (2)
session = null; - 0.02% (2)
sessionfactory sessionfactory; session - 0.02% (2)
package com.beingjavaguys.dao; import - 0.02% (2)
exception; public boolean - 0.02% (2)
com.beingjavaguys.model.employee; public interface - 0.02% (2)
spring and hibernate - 0.02% (2)
message; } public - 0.02% (2)
this.code = code; - 0.02% (2)
= message; } - 0.02% (2)
{ private int - 0.02% (2)
name="sessionfactory" ref="sessionfactory" /> - 0.02% (2)
profile page !!! - 0.02% (2)
it in eclipse. - 0.02% (2)
- 0.02% (2)
pom.xml alter table `employee` - 0.02% (2)
set latin1 */; - 0.02% (2)
/*!40100 default character - 0.02% (2)
create database if - 0.02% (2)
-- dumping database - 0.02% (2)
in our application, - 0.02% (2)
: dynamic web - 0.02% (2)
create a simple - 0.02% (2)
com.google.code.gson - 0.02% (2)
how to create - 0.02% (2)
this particular blog - 0.02% (2)
discussions we came - 0.02% (2)
in our previous - 0.02% (2)
– server application - 0.02% (2)
using maven – - 0.02% (2)
"skydrive" facebook twitter - 0.02% (2)
team download "spring - 0.02% (2)
on server and - 0.02% (2)
run the application - 0.02% (2)
spring-orm ${spring.version}
- 0.02% (2)
gson 2.2.2
- 0.02% (2)
org.hibernate.dialect.mysql5dialect - 0.02% (2)
classes with annotations. - 0.02% (2)
- 0.02% (2)
/> - 0.02% (2)
- 0.02% (2)
/> class="org.springframework.jdbc.datasource.drivermanagerdatasource"> /> service and dao - 0.02% (2)
beans here for - 0.02% (2)
and find controller - 0.02% (2)
mysql mysql-connector-java - 0.02% (2)
entry for base-package - 0.02% (2)
itself as per - 0.02% (2)
by spring framework - 0.02% (2)
will be served - 0.02% (2)
the container that - 0.02% (2)
this will tell - 0.02% (2)
entry to web.xml, - 0.02% (2)
make an spring - 0.02% (2)
\src\main\webapp\web-inf\web.xml - 0.02% (2)
class="org.springframework.orm.hibernate4.localsessionfactorybean"> how to configure - 0.02% (2)
/> employee = new - 0.02% (2)
the query is - 0.02% (2)
} ****created session - 0.02% (2)
transaction.commit(); session1.close(); system.out.println("****closed - 0.02% (2)
transaction = session1.begintransaction(); - 0.02% (2)
session1 = sessionfactory.opensession(); - 0.02% (2)
creation completed****"); session - 0.02% (2)
transaction.commit(); session.close(); system.out.println("****data - 0.02% (2)
sessionfactory.opensession(); transaction transaction - 0.02% (2)
in employee table - 0.02% (2)
save few data - 0.02% (2)
"9898787676"); // lets - 0.02% (2)
employee("eddy", "smith", "eddy@beingjavaguys.com", - 0.02% (2)
in db employee - 0.02% (2)
on cache. 2) - 0.02% (2)
object to persist - 0.02% (2)
create an employee - 0.02% (2)
= hibernateutils.getsessionfactory(); // - 0.02% (2)
{ sessionfactory sessionfactory - 0.02% (2)
com.beingjavaguys.models.employee; import com.beingjavaguys.utils.hibernateutils; - 0.02% (2)
package com.beingjavaguys.sample; import - 0.02% (2)
the cache is - 0.02% (2)
cache using evict() - 0.02% (2)
the session is - 0.02% (2)
for all upcoming - 0.02% (2)
hibernate first level - 0.02% (2)
level caching is - 0.02% (2)
in hibernate first - 0.02% (2)
we requested for - 0.02% (2)
the cache. 3) - 0.02% (2)
the number of - 0.02% (2)
transaction transaction = - 0.02% (2)
level caching and - 0.02% (2)
articles we will - 0.02% (2)
using evict() and - 0.02% (2)
we look into - 0.02% (2)
employee entity, hibernate - 0.02% (2)
came to get - 0.02% (2)
requested for the - 0.02% (2)
is what happened - 0.02% (2)
session1.begintransaction(); employee = - 0.02% (2)
completed****"); session session1 - 0.02% (2)
session.close(); system.out.println("****data creation - 0.02% (2)
session.begintransaction(); session.save(employee); transaction.commit(); - 0.02% (2)
employee table session - 0.02% (2)
get employee entity, - 0.02% (2)
few data in - 0.02% (2)
// lets save - 0.02% (2)
"smith", "eddy@beingjavaguys.com", "9898787676"); - 0.02% (2)
= new employee("eddy", - 0.02% (2)
db employee employee - 0.02% (2)
to persist in - 0.02% (2)
an employee object - 0.02% (2)
hibernateutils.getsessionfactory(); // create - 0.02% (2)
sessionfactory sessionfactory = - 0.02% (2)
import com.beingjavaguys.utils.hibernateutils; /** - 0.02% (2)
org.hibernate.transaction; import com.beingjavaguys.models.employee; - 0.02% (2)
com.beingjavaguys.sample; import org.hibernate.session; - 0.02% (2)
and clear() works - 0.02% (2)
second level caching - 0.02% (2)
example nagesh chauhan - 0.02% (2)
posts spring security - 0.02% (2)
10; list.foreach(i -> - 0.02% (2)
1 we have - 0.02% (2)
{ system.out.println(i); } - 0.02% (2)
static method as - 0.02% (2)
as lambda consumer - 0.02% (2)
existing static method - 0.02% (2)
1 of passing - 0.02% (2)
can pass a - 0.02% (2)
inner classes can - 0.02% (2)
classes can have - 0.02% (2)
points to the - 0.02% (2)
in lambda expressions - 0.02% (2)
4, 5); int - 0.02% (2)
we can see - 0.02% (2)
and does not - 0.02% (2)
we can assign - 0.02% (2)
we can define - 0.02% (2)
an lambda expression, - 0.02% (2)
printing a list - 0.02% (2)
to a function - 0.02% (2)
can be passed - 0.02% (2)
can be assigned - 0.02% (2)
we will discuss - 0.02% (2)
in this article - 0.02% (2)
8 lambda expressions - 0.02% (2)
february 2016 java - 0.02% (2)
tutorials tips and - 0.02% (2)
mahout and hadoop - 0.02% (2)
of type integer - 0.02% (2)
passed to a - 0.02% (2)
with help of - 0.02% (2)
oriented programming language - 0.02% (2)
one can write - 0.02% (2)
c and c++ - 0.02% (2)
a very simple - 0.02% (2)
run on any - 0.02% (2)
one platform can - 0.02% (2)
java program written - 0.02% (2)
open source programming - 0.02% (2)
most commonly used - 0.02% (2)
on any other - 0.02% (2)
platform can run - 0.02% (2)
program written and - 0.02% (2)
source programming language - 0.02% (2)
no comments ask - 0.02% (2)
passing existing constructor - 0.02% (2)
} this is - 0.02% (2)
todo auto-generated method - 0.02% (2)
default void b() - 0.02% (2)
public void a(); - 0.02% (2)
forced to override - 0.02% (2)
be used for - 0.02% (2)
auto-generated method stub - 0.02% (2)
{ // todo - 0.02% (2)
} class classa - 0.02% (2)
void a(); default - 0.02% (2)
if we have - 0.02% (2)
default methods in - 0.02% (2)
as lambda functioncan be found - 0.02% (2)
example with database - 0.02% (2)
id="datasource" class="org.springframework.jdbc.datasource.drivermanagerdatasource"> latin1 */; use - 0.02% (2)
security --> - 0.02% (2)
org.springframework spring-orm ${spring.version} - 0.02% (2)
- 0.02% (2)
hibernate-entitymanager ${hibernate.version}
- 0.02% (2)
webapp http://maven.apache.org - 0.02% (2)
/*!40014 set foreign_key_checks=1 - 0.02% (2)
alter table `user_roles` - 0.02% (2)
(`username`) ) engine=innodb - 0.02% (2)
not null auto_increment, - 0.02% (2)
for table spring_social_db.user_roles - 0.02% (2)
alter table `users` - 0.02% (2)
not null, primary - 0.02% (2)
default character set - 0.02% (2)
org.springframework.security - 0.02% (2)
database if not - 0.02% (2)
dumping database structure - 0.02% (2)
we have created - 0.02% (2)
web project with - 0.02% (2)
on : dynamic - 0.02% (2)
configure spring security - 0.02% (2)
blog we will - 0.02% (2)
previous discussions we - 0.02% (2)
java) facebook twitter - 0.02% (2)
java (neo4j + - 0.02% (2)
– neo4j with - 0.02% (2)
db) with java - 0.02% (2)
integrate neo4j (graph - 0.02% (2)
org.springframework.security spring-security-web ${spring.security.version} - 0.02% (2)
spring-security-config ${spring.security.version}
- 0.02% (2)
with @responsebody annotation - 0.02% (2)
springsecurityfilterchain org.springframework.web.filter.delegatingfilterproxy - 0.02% (2)
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"> with database. more - 0.02% (2)
bean to connect - 0.02% (2)
and a datasource - 0.02% (2)
annotations. we defined - 0.02% (2)
search and find - 0.02% (2)
added entry for - 0.02% (2)
file, we have - 0.02% (2)
\src\main\webapp\web-inf\spring-config.xml this is - 0.02% (2)
/* - 0.02% (2)
springsecurityfilterchain - 0.02% (2)
mvc-dispatcher - 0.02% (2)
per the configuration. - 0.02% (2)
framework itself as - 0.02% (2)
served by spring - 0.02% (2)
tell the container - 0.02% (2)
web.xml, this will - 0.02% (2)
spring entry to - 0.02% (2)
to make an - 0.02% (2)
\src\main\webapp\web-inf\web.xml we need - 0.02% (2)
(spring + json) - 0.02% (2)
- json response - 0.02% (2)
credentials spring 4 - 0.02% (2)
restful web services. - 0.02% (2)
2.2.2 - 0.02% (2)
com.google.code.gson gson - 0.02% (2)
org.springframework.security spring-security-config ${spring.security.version} - 0.02% (2)
org.springframework.security spring-security-web - 0.02% (2)
${spring.version}
- 0.02% (2)
import com.beingjavaguys.models.user; /** - 0.02% (2)
import java.util.arraylist; import - 0.02% (2)
com.beingjavaguys.models.user; /** * - 0.02% (2)
restcontroller { @autowired - 0.02% (2)
import org.springframework.web.bind.annotation.requestmethod; import - 0.02% (2)
a simple spring - 0.02% (2)
and you will - 0.02% (2)
- 0.02% (2)
a new access - 0.02% (2)
the token is - 0.02% (2)
that returns a - 0.02% (2)
a new token - 0.02% (2)
+ java) facebook - 0.02% (2)
with java (neo4j - 0.02% (2)
java – neo4j - 0.02% (2)
(graph db) with - 0.02% (2)
json) integrate neo4j - 0.02% (2)
annotation (spring + - 0.02% (2)
response with @responsebody - 0.02% (2)
mvc - json - 0.02% (2)
authorization example spring - 0.02% (2)
org.codehaus.jackson jackson-mapper-asl 1.9.10 - 0.02% (2)
- 0.02% (2)
example spring mvc - 0.02% (2)
return email; } - 0.02% (2)
hibernate 4 spring - 0.02% (2)
with database credentials - 0.02% (2)
will see more - 0.02% (2)
spring, hibernate, solr, - 0.02% (2)
security and oauth2, - 0.02% (2)
services with spring - 0.02% (2)
securing restful web - 0.02% (2)
setphone(string phone) { - 0.02% (2)
{ return phone; - 0.02% (2)
public string getphone() - 0.02% (2)
= email; } - 0.02% (2)
email) { this.email - 0.02% (2)
public void setemail(string - 0.02% (2)
string getemail() { - 0.02% (2)
class="org.springframework.security.oauth2.provider.error.oauth2authenticationentrypoint"> { return id; - 0.02% (2)
string phone; public - 0.02% (2)
here is a - 0.02% (2)
springsecurityfilterchain /*
- 0.02% (2)
org.springframework.web.filter.delegatingfilterproxy - 0.02% (2)
--> springsecurityfilterchain - 0.02% (2)
/web-inf/spring-security.xml - 0.02% (2)
contextconfiglocation /web-inf/mvc-dispatcher-servlet.xml, - 0.02% (2)
org.springframework.web.context.contextloaderlistener - 0.02% (2)
/ - 0.02% (2)
mvc-dispatcher org.springframework.web.servlet.dispatcherservlet 1 - 0.02% (2)
ref="clientdetails" />
- 0.02% (2)
we have used - 0.02% (2)
add end --> - 0.02% (2)

Here you can find chart of all your popular one, two and three word phrases. Google and others search engines means your page is about words you use frequently.

Copyright © 2015-2016 hupso.pl. All rights reserved. FB | +G | Twitter

Hupso.pl jest serwisem internetowym, w którym jednym kliknieciem możesz szybko i łatwo sprawdź stronę www pod kątem SEO. Oferujemy darmowe pozycjonowanie stron internetowych oraz wycena domen i stron internetowych. Prowadzimy ranking polskich stron internetowych oraz ranking stron alexa.