Skip to content

Instantly share code, notes, and snippets.

Last active Jul 15, 2020
What would you like to do?
All about Hibernate
-framework for persisting java objects to DB
- handles all low level SQL code
- minimizes amount of JDBC code
- provides ORM (Object to Relational Mapping)
- developer defines mapping between java class and database table using xml or java
saving objects
- create objects
- - session object is provided by hibernate framework , will return id as well(primary key)
- sessioin.get(classname, id) - gives back the data from db
all the students
- create query = session.createQuery("from Student")
list = query.list()
Hibernate and JDBC??
Hibernate uses JDBC for all db communication
- another layer of extraction on top of jdbc
environmental setup
- Java IDE
- DB server
- Hibernate jar files and JDBC driver
- first make db ready
- then eclipse
- new project
- add hibernate files - lib->required copy,
- add mysql jdbc driver - mysql java connector -> connector.jar
- add jar files to build path
test jdbc
- start mysql server from xampp or other
- just give url, and try to connect it with boilerplate code - new class
hibernate development process
- add hibernate config - tells how to connect to db (bulk is jdbc things) , sql dialect, log sql or not, session context=thread, pool size etc
- annotata java class - called Entity(@entity) class - java class with setters and getters with annotations specific to hibernate
- map class to table @table & map fields to columns (@column) , @id for primary key
// if same name for field and db - no need of annotaition - still preferred
use imports from java persistence api JPA
//JPA is a standard specification. Hibernate is an implementation of the JPA specification. Hibernate implements all of the JPA annotations.
////The Hibernate team recommends the use of JPA annotations as a best practice.
- develop java code to perform db operations
create factory using hibernate config xml(name not mandatory) and entity files
create session suing factory
do operations with session
- begin transaction
- save/retrieve
-commit transaction etc
Key players
- Reads hibernate config files
- Creates session objects
- Only created once in app - heavy weighted
- wrapper around jdbc connection
- main object for save/retrieve objects
- short lived - use and throw
- retreived from sessionfactory
Spring - 5 is the main guy -
- reactive programming with webflux and all
java EE 7 is also similar
light weight
seperation with ioc, and DI
application wide services with AOP
creating beans and making it available
application wide - logging, etc
using annotations and config files
Data Access Layer
if springs integrated services 50 % code reduction
Web layer
home of web application
Test layer
other addons
spring security
web services etc
env setup
1.tomcat 9 installed as a service - start and stop using monitor
2,eclipes EE edition - web support is there
3, add server in eclipse - point to tomcat path - will show server then
----------------- - starter kit
- just create a java project
- download spring release - contains all jar, core, aop etc
- extract it and add to project - lib directory
- add it to java build path - libraries - will show up in referenced libraries in eclipse
inversion of control
outsourcing the construction and mngnt of objects
traditionally - we have to do hard change. ioc helps to do with config files
one object factory will return the needed object - concept
Spring container -
creates and manages object - ioc
inject object's dependencies - DI
configuring spring container
xml - legacy - add everything in xml
java annotations - add component scan alone in xml, rest annotations
java source code - no xml files at all., config also using java source code
Development process
configuring spring beans
create spring container
retrieve beans from container
1. applicationContext.xml
bean id = className // used to retrieve a bean from a container
class= fullpath
spring container = application context
specific implemenations like classpathxmlappcontxt, annotationconfigappcontext etc
create the container using this context object and by passing xml to it
2. retreiving beans
use context.getbean(beanId in config file, classname)
// A "Spring Bean" is simply a Java object.
When Java objects are created by the Spring Container, then Spring refers to them as "Spring Beans".
3. call method on that bean object.
- now app is configurable - just change the className in context.xml - app will behave differently
reason for giving interface name in getBeans param :
Behaves the same as getBean(String), but provides a measure of type safety by throwing a BeanNotOfRequiredTypeException if the bean is not of the required type. This means that ClassCastException can't be thrown on casting the result correctly, as can happen with getBean(String).
Dependency injection
delegates the construction of object to another
- many types
- constructor injection
- setter injection
- also autowiring is there
constructor injection
Development process:
1,define dependency interface and class - new interface and implementation class
2, create constructor in your class for injection - add that attribute and create a constructor where we want to implement it
3, config in config file - define both above in config file
setter injection
Development process:
1, configure setter method in class for injections - no arg constructor & setter method
2, config in config file
injecting literal values ( email address etc)
1, add property and setters
2, add in config - hardcode value
getting values from property file - avoid hardcoding
- create ppty file
- load in config file
- reference value from ppty file
bean scopes
default singleton
- only one instance is created, cached and reference is shared
- stateless bean
other scopes -
prototype = new instance of each container request - stateful data
global-session -all 3 web
just add scope = prototype in config - will point to different memory location - indicates different objects are created like the new keyword
bean lifecycle
init, destroy can be called- add in config file
// For "prototype" scoped beans, Spring does not call the destroy method. Gasp!
configuration using annotations - ioc
special labels or markers added to java class
provide meta-data about class - infos
processed at compile or run time
"xml config can be verbose and difficult to maintain - so annotations"
enable annotation in config - add entry with package
add @component in class
retrieve bean from container
default bean id - instead of we giving , spring will generate auto
- just remove explicit bean id - spring generates classname based bean with first letter small
no explicit name given, automatically does eg: Home = home
special case of when BOTH the first and second characters of the class name are upper case, then the name is NOT converted. eg: REST = REST
DI using annotations
- uses 'autowiring'
looks for matching class or interface and automatically injects
- constructor injection
- setter injection
- field injection
- define dependency interface and class
- create constructore in class for injections
- configure with @Autowired annotation
@Qualifier annotation - if there are multiple implemenations
constructor based autowiring
- create interface and impl
- create method in class's interface
- create local variable and constructor in impl and autowire
- use it as usual
//As of Spring Framework 4.3, an @Autowired annotation on such a constructor is no longer necessary if the target bean only defines one constructor to begin with. However, if several constructors are available, at least one must be annotated to teach the container which one to use.
setter based autowiring
-- create setter method & no arg constructor in class
-- use @
can be used with any method name
field injection using @autowired
- even on private field
// use any of the above and stick to it
- give bean name - default is fine
// in constructer based - @Autowired
public TennisCoach(@Qualifier("randomFortuneService") FortuneService theFortuneService) {
// inside
values from ppty file
- similar
- add in config
then inject
eg: @Value("${}")
private String email;
bean scopes with annotation
add @scope(scopename)
bean lifecycle/ hooks
@postConstruct and @preDestroy
Spring cofiguration using java source code
java class for config and annotate as @configuration
add component scan support using @componentscan (optional)
read java config file - no quotations - use annotationconfigappcontext
retrieve bean
Define spring bean with java code
- define mehtod to expose bean
-inject bean dependencies
- read spring java config class
- retreive bean
injecting value from ppty file using java
- create , load and reference
All about Spring MVC
- framwork for building web apps
- based on MVC
- Leverages core spring things - ioc, DI
web browser - front controller (creates model) - controller (model) - View template - browser
components of spring MVC
- set of web pages
- collection of spring beans (controllers, services)
-Spring config (xml, annotations, java)
front controller (dispatcherServlet) already present
we will create model, the view pages and controller (business logic)
- handle request
- Store/retrieve data (db, web service etc)
- place data in model
- send to appropriate view
- contains data ( any type)
- controllers places data here ( like a suitcase)
- supports many,flexible
common - JSP + JSTL
also thymeleaf, groovy etc
displays data from model to users
environmental setup
- eclipse (JEE perspective)
- tomcat
- connect it
- add configs to WEB-INF/web.xml
1, spring mvc dispatcherServlet
2, setup URL mappings to spring mvc dispatcherServlet
- add configs to WEB-INF/spring-mvc-demo-servlet.xml
1, add support to spring componet scanning
2,add support to conversion, formatiing and validation
3, configure spring mvc view resolver
new - dynamic web project
- copy all spring jars to web content- web inf - lib
- copy jstl support jar files as well
- copy web.xml (with web app tag) - contains dispatcherServlet setup and path to it
and application context xml (with bean tag) - contains component scan, validators support , view location and url prefix/suffix to it
- create a view folder in web.inf
// setup can also done wihtout xml - later
a flow
controller class - > -- use @controller - it extends @component - so scanning will pickup
controller method - > -- add a method - any name is fine ( can accept many params like reqparam etc) & also can return many combos - later
request mapping -- add @requestMapping annotation with url
return view name -- return from method , name - springconfig will append pre and suffix and page is found
develop view page -- normal jsp page with markups
create a package inside java resources - src & create controller there
and view file in view folder
then run on server - (change hyphen in tomcat console if port error, also change the default browser)
///tomcat auto reloads
form - add 2 request mappings - one for showing form and getting input from form
- usual way, get it and show it from param
adding data to spring model
- value from can be accessed using httpservletrequest.getParameter - which is available in controller
- then add model also in parameter
- model.addAttribute will put in model, with a name
accessing static resources
- place in webcontent -> resources folder (any name, and segregate to corresponding folder if needed)
-then add below lines in app context.xml
<mvc:resources mapping="/resources/**" location="/resources/"></mvc:resources>
-then access as below
<link rel="stylesheet" type="text/css"
<script src="${pageContext.request.contextPath}/resources/js/simple-test.js"></script>
<img src="${pageContext.request.contextPath}/resources/images/spring-logo.png" />
Deploying your App to Tomcat as a Web Application Archive (WAR) file
The Web Application Archive (WAR) file is a compressed version of your web application. It uses the zip file format but the file has the .war extension.
1. In Eclipse, stop Tomcat
2. Right-click your project and select Export > WAR File
3. In the Destination field, enter: <any-directory>/mycoolapp.war
4. Outside of Eclipse, start Tomcat
- If you are using MS Windows, then you should find it on the Start menu
5. Make sure Tomcat is up and running by visiting: http://localhost:8080
6. Deploy your new WAR file by copying it to <tomcat-install-directory>\webapps
Give it about 10-15 seconds to make the deployment. You'll know the deployment is over because you'll see a new folder created in webapps ... with your WAR file name.
7. Visit your new app. If your war file was: mycoolapp.war then you can access it with: http://localhost:8080/mycoolapp/
Request Param & Request mapping
- instead of getting from servlet- add annotation @requestparam
controller request mapping (/foo) - all other controllers underneath are relative then (/foo/bar)
- can be used to resolve issues, when 2 same mappings are there in different controllers
FORM tags eg: <form:form>
- lot of form related tags are there, which will auto binds data to model ( add spring taglib library for form in jsp page)
- model has to be injected
- in controller, add form object as model attribute
- add same name as model attribute in <form:form> as well
after submitting
- in controller add a new mapping where modelattribte is taken as param
- then in return jsp, model is available, fetch from it show to user
tags: examples
How to use properties file to load country options
This solution will show you how to place the country options in a properties file. The values will no longer be hard coded in the Java code.
1. Create a properties file to hold the countries. It will be a name value pair. Country code is name. Country name is the value.
New text file: WEB-INF/
Note the location of the properties file is very important. It must be stored in WEB-INF/
2. Update header section for Spring config file
We are going to use a new set of Spring tags for <util>. As a result, you need to update the header information in the Spring config file.
File: spring-mvc-dmo-servlet.xml
Remove the previous header and add this.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""
3. Load the country options properties file in the Spring config file. Bean id: countryOptions
File: spring-mvc-dmo-servlet.xml
Add the following lines:
<util:properties id="countryOptions" location="classpath:../" />
4.1 In, add the following import statement:
import java.util.Map;
4.2 Inject the properties values into your Spring Controller:
private Map<String, String> countryOptions;
5. Add the country options to the Spring MVC model. Attribute name: theCountryOptions
public String showForm(Model theModel) {
// create a student object Student
Student theStudent = new Student();
// add student object to the model
theModel.addAttribute("student", theStudent);
// add the country options to the model
theModel.addAttribute("theCountryOptions", countryOptions);
return "student-form";
6. Update the JSP page, student-form.jsp, to use the new model attribute for the drop-down list: theCountryOptions
<form:select path="country">
<form:options items="${theCountryOptions}" />
7. Remove all references to country option from your
radio buttons
- form:radio
from list in java class
<form:radiobuttons path="favoriteLanguage" items="${student.favoriteLanguageOptions}" />
- form checkbox - more than one option
- get in a array and display using c tag from jstl
FORM Validations
- java has standard bean validation api
- not tied to web or persistence layer
@NotNull, @Min, @Size, @pattern etc
- Hibernate validator is used - download the zip
- in dist, copy main 3 jars and jars in required folder to lib
- steps
- when validation fails, request is redirected back
1, add validation annotations to field, with messages
2, add form:error in form , add css class as well
3, check form errors in controller in bindingResult, ( add @valid to customer attribute & add to bindingResult)
//the BindingResult parameter must appear immediately after the model attribute.
redirect back to form or redirect to success page based on result
// whitespace should be trimmed
@initbinder preprocessor is used
@min & @max
add min/max value and messages
@pattern (regex and message)
@required for int
wont work - make it to primitive
handling string input for integer field
custom errors
- add property file under src/resources - and check errrorcode and bypass it with from ppty value (debug and see)
- add entry in appcontext to read the ppty file
CUSTOM business validation
- create custom annotation
- new package
- new annotation class
- add @constraint - clas which validates, @Target - field/method, @retention - runtime etc
- default value and error - and some default things
in extened constrainValidator - initialize the value, compare with present and return result, as an example
- also can be validated against array of strings
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment