In this post, the steps of configuring the project is introduced.
Step 1: Create a project with required directory structure
The important folders include sources root and resources root
Step 2: Import dependencies in pom.xml
Include junit, mybatis, mybits-spring, mybatis-generator-core, mysql-connector-java, c3p0, spring-context, spring-test, spring-beans, spring-webmvc, spring-jdbc, spring-aspects, jstl, javax.servelt-api, jsqlparser, log4j, commons-logging, commons-fileupload, commons-io, commons-lang, aopalliance. Note: the versions of these dependencies may have conflicts. The code is as follows.
6.2: Configure jdbc connection pool. To be specific, create a bean named dataSource, where we set properties of c3p0 connection pool.
The most straightforward way to create a c3p0 pooling DataSource is to instantiate an instance of com.mchange.v2.c3p0.ComboPooledDataSource. This is a JavaBean-style class with a public, no-arg constructor, but before you use the DataSource, you’ll have to be sure to set at least the property jdbcUrl. You may also want to set user and password, and, if you use an old-style JDBC driver that you will not externally preload, you should set the driverClass.
6.3: Build a SqlSessionFactory instance from an XML file, set properties, e.g. typeAliasesPackage, dataSource, configLocation, mapperLocations.
typeAliasesPackage: A type alias is a shorter name for a Java type, to reduce redundante typing of fully qualified classnames. You can also specify a package where MyBatis will search for beans.
dataSource: configures the source of JDBC Conntection objexts using standard JDBC DataSource interface.
configLocation: tell MyBatis where to find configuration file.
mapperLocation: tell MyBatis where to find mapped SQL statements.
Whenever we have a sqlSesstionFactory, we can create sqlSessions. The sqlSession then executes SQL Statements.
SqlSessionFactoryBuilder This class can be instantiated, used and thrown away. There is no need to keep it around once you’ve created your SqlSessionFactory. Therefore the best scope for instances of SqlSessionFactoryBuilder is method scope (i.e. a local method variable). You can reuse the SqlSessionFactoryBuilder to build multiple SqlSessionFactory instances, but it’s still best not to keep it around to ensure that all of the XML parsing resources are freed up for more important things.
SqlSessionFactory Once created, the SqlSessionFactory should exist for the duration of your application execution. There should be little or no reason to ever dispose of it or recreate it. It’s a best practice to not rebuild the SqlSessionFactory multiple times in an application run. Therefore the best scope of SqlSessionFactory is application scope. This can be achieved a number of ways. The simplest is to use a Singleton pattern or Static Singleton pattern.
SqlSession Each thread should have its own instance of SqlSession. Instances of SqlSession are not to be shared and are not thread safe. Therefore the best scope is request or method scope. Never keep references to a SqlSession instance in a static field or even an instance field of a class. Never keep references to a SqlSession in any sort of managed scope, such as HttpSession of the Servlet framework. If you’re using a web framework of any sort, consider the SqlSession to follow a similar scope to that of an HTTP request. In other words, upon receiving an HTTP request, you can open a SqlSession, then upon returning the response, you can close it. Closing the session is very important. You should always ensure that it’s closed within a finally block.
6.4: Regist a mapper in spring, i.e. create a bean named MapperScannerConfigurer, specify sqlSessionFactoryBeanName, basePackage
basePackage: let you set the base package for your mapper interface files.
sqlSessionFactoryBeanName: specify a specific sqlSessionFactory.
The whole code in spring-dao.xml is as follows.
CLICK ME
Step 7. spring-service configuration
7.1: Add context and transaction (i.e tx) schema in the head line, i.e.
7.3: Configure transactionManager When using transaction management in Spring, we need to define transactionManager. Typically we can define this through dependency injection. The related bean definition will then have a reference to the DataSource definition.
The code is as follows.
CLICK ME
What is transation ? source A database transaction is a sequence of actions that are treated as a single unit of work. These actions should either complete entirely or take no effect at all. Transaction management is an important part of RDBMS-oriented enterprise application to ensure data integrity and consistency. The concept of transactions can be described with the following four key properties described as ACID − Atomicity, Consistency, Isolation, Durability.
Step 8. Spring-web configuration, i.e. SpringMVC configuration
8.1: start SpringMVC annotation
mvc:annotation-driven is used for enabling the Spring MVC components with its default configurations. If you dont include mvc:annotation-driven also your MVC application would work if you have used the context:component-scan for creating the beans or defined the beans in your XML file. But, mvc:annotation-driven does some extra job on configuring the special beans that would not have been configured if you are not using this element in your XML file.
8.2: specify the location of static resources, including .js, .gif, .png, .css,…
Steps to include static resources, e.g. css, js, into JSP page:
Put static resources like cs, js or images into this folder webapp\resources
Create a Spring mvc:resources mapping
Include in JSP page via JSTL tag c:url or Spring tag spring:url
8.3: define ViewResolver When using JSP for a view technology you can use the UrlBasedViewResolver. This view resolver translates a view name to a URL and hands the request over to the RequestDispatcher to render the view.
8.4: define multipartResolver
8.5: define context:component-scan
The difference between <context:annotation-config /> and <context:component-scan />
Spring allows you to do two things: Autowiring of beans and Autodiscovery of beans
Autowiring Usually in applicationContext.xml you define beans and other beans are wired using constructor or setter methods. You can wire beans using XML or annotations. In case you use annotations, you need to activate annotations and you have to add <context:annotation-config /> in applicationContext.xml. This will simplify the structure of the tag from applicationContext.xml, because you will not have to manually wire beans (constructor or setter). You can use @Autowire annotation and the beans will be wired by type.
A step forward for escaping the manual XML configuration is
Autodiscovery Autodiscovery is simplifying the XML one step further, in the sense that you don’t even need too add the <bean> tag in applicationContext.xml. You just mark the specific beans with one of the following annotation and Spring will automatically wire the marked beans and their dependencies into the Spring container. The annotations are as follow: @Controller, @Service, @Component, @Repository. By using <context:component-scan> and pointing the base package, Spring will auto-discover and wire the components into Spring container.
As a conclusion:
<context:annotation-config /> is used in order to be able to use @Autowired annotation
<context:component-scan /> is used to determine the search of specific beans and attempt of autowiring.
