项目搭建采用技术栈为：Spring+Spring MVC+Hibernate+Jsp+Gradle＋tomcat+mysql5.6

搭建环境文档目录结构说明：

  1. 使用Intellj Idea 搭建项目过程详解
  2. 项目各配置文件讲解及部署
  3. 各层包功能讲解&项目搭建完毕最终效果演示图
  4. 项目中重要代码讲解
  5. webapp文件夹下分层详解
  6. 配置tomcat 运行环境

1. 使用Intellj Idea 搭建项目过程详解

1.1 打开Intellj Idea

 
Intellj idea 截图

1.2 操纵 Intellj Idea 工具栏 新建项目

 
操纵idea 工具栏
 
使用Gradle创建项目
 
完善项目信息
 
设置Gradle
 
确定项目信息
 
选择New Window
 
初始化项目结构截图

需要说明的是，最初创建的项目视图是不完整的，包括webapp文件夹下没有web.xml，以及src包下缺少Java文件夹(放置java源代码文件)，Resources文件夹（放置项目配置文件）。
我们继续做以下操作，使得项目的结构符合web 应用项目的层级标准。

 
操纵工具栏为项目添加 web.xml全局配置文件

出现如下视图：

 
新建 web.xml文件
 
设置web.xml文件存储位置

接下来：单击main文件夹按照如下操作：

 
手动创建src中main文件夹下java目录
 
输入java 文件夹名称

点击ok，再按照上图操作操作一遍，输入文件名为resources
最终的结构图如下图所示：

 
项目最终结构图

2. 项目各配置文件讲解及部署

完成了项目的初始化结构创建，接下来我们需要来创建配置文件。
首先是resources文件夹下的配置文件
2.1 resources下资源文件截图:(最终配置的结果)

 
项目所需配置文件最终配置结果

2.2 data-access-applicationContext.xml
主要管理数据库访问组件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/context
  8.        http://www.springframework.org/schema/context/spring-context.xsd
  9.        ">
  11.     <!-- 配置自动扫描的包 -->
  12.     <context:component-scan base-package="com.fxmms" use-default-filters="false">
  13.         <context:include-filter type="regex" expression="com.fxmms.*.*.dao.*"/>
  14.         <context:include-filter type="regex" expression="com.fxmms.*.dao.*"/>
  15.     </context:component-scan>
  17.     <!-- 配置数据源 -->
  18.     <context:property-placeholder location="classpath:db.properties"/>
  19.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  20.         <property name="driverClassName" value="${jdbc.driverClass}"/>
  21.         <property name="url" value="${jdbc.jdbcUrl}"/>
  22.         <property name="username" value="${jdbc.user}"/>
  23.         <property name="password" value="${jdbc.password}"/>
  24.     </bean>
  26.     <!--配置hibernate SessionFactory-->
  27.     <bean id="sessionFactory"
  28.           class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
  29.         <property name="dataSource" ref="dataSource"></property>
  30.         <property name="hibernateProperties">
  31.             <props>
  32.                 <prop key="hibernate.dialect">${dataSource.hibernate.dialect}</prop>
  33.                 <prop key="hibernate.show_sql">${dataSource.hibernate.show_sql}</prop>
  34.                 <prop key="hibernate.format_sql">true</prop>
  35.                 <!--负责自动创建数据表，基本上不能打开注释，否则所有的数据库中表信息都会被删除，重新创建-->
  36.                 <!-- <prop key="hibernate.hbm2ddl.auto">create</prop> -->
  37.             </props>
  38.         </property>
  39.         <!-- <property name="hibernate.jdbc.batch_size" value="50"></property> -->
  40.         <property name="packagesToScan">
  41.             <list>
  42.                 <value>com.fxmms.*.*.domain</value>
  43.                 <value>com.fxmms.*.domain</value>
  44.             </list>
  45.         </property>
  46.     </bean>
  48.     <!--jdbcTemplate start -->
  49.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  50.         <property name="dataSource" ref="dataSource"></property>
  51.     </bean>
  52.     <!--Spring JDBC 中操作 LOB 数据 -->
  53.     <bean id="lobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler"
  54.           lazy-init="true"></bean>
  55.     <!-- 配置JPA部分 -->
  56.     <!-- 配置JPA的EntityManagerFactory -->
  57.     <!-- <bean id="entityManagerFactory"
  58.            class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
  59.          <property name="dataSource" ref="dataSource"></property>
  60.          <property name="jpaVendorAdapter">
  61.              <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
  62.          </property>
  63.          <property name="packagesToScan" value="com.fxmms"></property>
  64.          <property name="jpaProperties">
  65.              <props>
  66.                  <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
  67.                  <prop key="hibernate.hbm2ddl.auto">update</prop>
  68.                  <prop key="hibernate.show_sql">true</prop>
  69.                  <prop key="hibernate.format_sql">true</prop>
  70.                  <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
  72.                  <prop key="hibernate.cache.use_second_level_cache">true</prop>
  73.                  <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory
  74.                  </prop>
  75.                  <prop key="hibernate.cache.use_query_cache">true</prop>
  76.              </props>
  77.          </property>
  78.          <!–使用二級緩存–>
  79.          <property name="sharedCacheMode" value="ENABLE_SELECTIVE"></property>
  80.      </bean>
  82.      <!– 配置事务 –>
  83.      <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
  84.          <property name="entityManagerFactory" ref="entityManagerFactory"></property>
  85.      </bean>-->
  87.     <!-- <!– 配置SpringData部分 –>
  88.      <jpa:repositories base-package="com.fxmms"
  89.                        entity-manager-factory-ref="entityManagerFactory">
  91.      </jpa:repositories>-->
  92. </beans>

2.3 service-applicationContext.xml
主要管理业务逻辑组件，包括对数据库访问的事务控制，以及定时任务。

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <beans xmlns="http://www.springframework.org/schema/beans"
  4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.        xmlns:context="http://www.springframework.org/schema/context"
  6.        xmlns:aop="http://www.springframework.org/schema/aop"
  7.        xmlns:task="http://www.springframework.org/schema/task"
  8.        xmlns:tx="http://www.springframework.org/schema/tx"
  9.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  10.   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  11.   http://www.springframework.org/schema/aop
  12.   http://www.springframework.org/schema/aop/spring-aop.xsd
  13.   http://www.springframework.org/schema/tx
  14.   http://www.springframework.org/schema/tx/spring-tx.xsd
  15.         http://www.springframework.org/schema/task
  16.         http://www.springframework.org/schema/task/spring-task.xsd">
  18.     <aop:aspectj-autoproxy/>
  20.     <!--设置定时任务-->
  21.     <task:annotation-driven/>
  22.     <context:component-scan base-package="com.fxmms.www" use-default-filters="false">
  23.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
  24.     </context:component-scan>
  26.     <!-- enable the configuration of transactional behavior based on annotations -->
  27.     <tx:annotation-driven transaction-manager="txManager"/>
  29.     <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
  30.         <property name="sessionFactory" ref="sessionFactory"/>
  31.     </bean>
  33. </beans>

2.4 default-servlet.xml
设置springmvc-applicationContext.xml,前端控制器将请求转发到相应的controller层中的处理方法上。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd
  8.        http://www.springframework.org/schema/context
  9.        http://www.springframework.org/schema/context/spring-context.xsd
  10.        http://www.springframework.org/schema/mvc
  11.        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  12.     <!---->
  13.     <mvc:annotation-driven>
  14.         <!--json解析-->
  15.         <mvc:message-converters>
  16.             <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
  17.             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
  18.         </mvc:message-converters>
  19.     </mvc:annotation-driven>
  20.     <context:component-scan base-package="com.fxmms.www.controller">
  21.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  22.     </context:component-scan>
  23.     <!--因为web.xml中defaultDispatcherServlet对所有请求进行了拦截，所以对一些.css .jpg .html .jsp也进行了拦截，所以此配置项
  24.     保证对对静态资源不拦截-->
  25.     <mvc:default-servlet-handler/>
  26.     <!--视图解析器-->
  27.     <bean id="viewResolver"
  28.           class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  29.         <property name="prefix" value="/WEB-INF/views/"/>
  30.         <property name="suffix" value=".jsp"/>
  31.     </bean>
  32.     <!--配置文件上上传-->
  33.     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  34.         <property name="defaultEncoding" value="utf-8"/>
  35.         <property name="maxUploadSize" value="10485760000"/>
  36.         <property name="maxInMemorySize" value="40960"/>
  37.     </bean>
  38. </beans>

2.5 spring-security.xml
设置spring－security 权限控制配置文件，项目中权限的控制统一在此配置文件中配置，包括从数据库中获取用户的相关信息，以及配置相应pattern的请求过滤规则。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:sec="http://www.springframework.org/schema/security"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  8.         http://www.springframework.org/schema/context
  9.         http://www.springframework.org/schema/context/spring-context.xsd
  10.         http://www.springframework.org/schema/security
  11.         http://www.springframework.org/schema/security/spring-security-3.2.xsd">
  12.     <!--    <sec:http pattern="/**/*.jpg" security="none"></sec:http>
  13.         <sec:http pattern="/**/*.jpeg" security="none"></sec:http>
  14.         <sec:http pattern="/**/*.gif" security="none"></sec:http>
  15.         <sec:http pattern="/**/*.png" security="none"></sec:http>s
  16.         <sec:http pattern="/getCode" security="none" /><!– 不过滤验证码 –>
  17.         <sec:http pattern="/test/**" security="none"></sec:http><!– 不过滤测试内容 –>-->
  18.     <!--spring security 权限管理配置文件-->
  19.     <context:component-scan base-package="com.fxmms.common.security">
  20.     </context:component-scan>
  21.     <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
  22.     <!--权限控制-->
  23.     <sec:http auto-config="true" use-expressions="true">
  24.         <sec:intercept-url pattern="/superadmin/**" access="hasRole('superadmin')"/>
  25.         <sec:intercept-url pattern="/admin/**" access="hasRole('admin')"/>
  26.         <sec:intercept-url pattern="/customer/**" access="hasRole('customer')"/>
  27.         <!--自定义登陆页面,权限验证失败页面，登录成功页面-->
  28.         <sec:form-login login-page="/login.jsp" authentication-failure-url="/login.jsp" login-processing-url="/j_spring_security_check"
  29.                         authentication-success-handler-ref="loginSuccessHandler"/>
  30.         <!--用户权限不一致出现的权限不可得情况，默认情况下跳转到403页面-->
  31.         <sec:access-denied-handler ref="accessDeniedServletHandler" />
  32.         <sec:logout logout-success-url="/login.jsp" />
  33.     </sec:http>
  35.     <sec:authentication-manager>
  36.         <sec:authentication-provider>
  37.             <!--配置从数据库查询用户权限  and isDelete = 0 and enable = 1-->
  38.             <sec:jdbc-user-service data-source-ref="dataSource"
  39.                                    users-by-username-query="select userName,password,enable  from mms_admin where userName=? and isDelete = 0 and enable = 1"
  40.                                    authorities-by-username-query="select userName,role from mms_admin where username=?"
  41.             ></sec:jdbc-user-service>
  42.         </sec:authentication-provider>
  43.     </sec:authentication-manager>
  44. </beans>

2.6 db.properties
数据库访问配置文件

  1. jdbc.user=root
  2. jdbc.password=feixun*123
  3. jdbc.driverClass=com.mysql.jdbc.Driver
  4. #jdbc.jdbcUrl=jdbc:mysql://localhost/fxmms?useUnicode=true&characterEncoding=UTF-8
  5. jdbc.jdbcUrl=jdbc:mysql://222.73.156.132:13306/fxmms?useUnicode=true&characterEncoding=UTF-8
  7. jdbc.initPoolSize=5
  8. jdbc.maxPoolSize=20
  9. dataSource.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
  10. #######################
  11. ##      local        ##
  12. #######################
  13. dataSource.hibernate.show_sql=true

2.7 log4j.properties
配置项目日志文件，日志输出模式为Console

  1. ###########################################################################
  2. # Properties file for the log4j logger system
  3. #
  4. #  Note: During the uPortal build, the file at /properties/Logger.properties is copied
  5. #  to the log4j standard location /WEB-INF/classes/log4j.properties .  This means that editing the file
  6. #  at /properties/Logger.properties in a deployed uPortal will have no effect.
  7. #
  8. # Please read the instructions for the Log4J logging system at
  9. # http://jakarta.apache.org/log4j/ if you want to modify this.
  11. ###########################################################################
  12. # You should probably replace the word "debug" with "info" in the
  13. # following line after everything is running.  This will turn off
  14. # the tons of debug messages, and leave only INFO, WARN, ERROR, etc.
  15. #
  16. log4j.rootLogger = info,stdout,D,E
  18. #配置stdout
  19. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  20. log4j.appender.stdout.Target=System.out
  21. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  22. log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH\:mm\:ss,SSS} [%p]-[%l] %m%n
  24. #配置D 保存info debug级别的系统日志信息
  25. log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
  26. #/Users/mark/mms/log.log 指定info debug级别日志信息存储位置
  27. log4j.appender.D.File = /Users/mark/mms/log.log
  28. log4j.appender.D.Append = true
  29. log4j.appender.D.Threshold = INFO,DEBUG
  30. log4j.appender.D.layout = org.apache.log4j.PatternLayout
  31. log4j.appender.D.layout.ConversionPattern = %d{yyyy-MM-dd HH\:mm\:ss,SSS} [%p]-[%l] %m%n
  33. #配置E 保存系统异常日志
  34. log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
  35. #/Users/mark/mms/error.log 指定info debug级别日志信息存储位置
  36. log4j.appender.E.File = /Users/mark/mms/error.log
  37. log4j.appender.E.Append = true
  38. log4j.appender.E.Threshold = ERROR
  39. log4j.appender.E.layout = org.apache.log4j.PatternLayout
  40. log4j.appender.E.layout.ConversionPattern = %d{yyyy-MM-dd HH\:mm\:ss,SSS} [%p]-[%l] %m%n
  42. #log4j.logger.org.hibernate=INFO
  43. #
  44. ## Log all JDBC parameters
  45. #log4j.logger.org.hibernate.type=ALL
  47. ##Hibernate begin 打印每次数据访问产生的sql语句至log.log 文件当中##
  48. log4j.logger.org.hibernate=info
  49. #配置SQL打印与输出
  50. log4j.logger.org.hibernate.SQL=DEBG
  51. log4j.logger.org.hibernate.HQL=DEGUG
  52. #log4j.logger.org.hibernate.type=ALL

2.8 web.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  5.          version="3.1">
  6.     <!--配置需要加载的spring配置文件，这些文件中的配置的类都是被<context:component-scan>扫描到的，比如@Repository @Component
  7.     @Service @Controller等-->
  8.     <context-param>
  9.         <param-name>contextConfigLocation</param-name>
  10.         <param-value>classpath:data-access-applicationContext.xml;classpath:spring-security.xml;classpath:service-applicationContext.xml</param-value>
  11.     </context-param>
  12.     <!--配置日志监听 ，如果配置文件报红，没有关系可以正常运行，这个与idea的验证规则有关-->
  13.     <context-param>
  14.         <param-name>log4jConfigLocation</param-name>
  15.         <param-value>classpath:log4j.properties</param-value>
  16.     </context-param>
  17.     <listener>
  18.         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
  19.     </listener>
  21.     <listener>
  22.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  23.     </listener>
  25.    <!--配置权限过滤器，注意必须配置在springmvc 之前，因为对用户访问资源的权限判断与控制是在访问特定url之前发生的-->
  26.     <filter>
  27.         <filter-name>springSecurityFilterChain</filter-name>
  28.         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  29.     </filter>
  30.     <filter-mapping>
  31.         <filter-name>springSecurityFilterChain</filter-name>
  32.         <url-pattern>/*</url-pattern>
  33.     </filter-mapping>
  35.     <!-- 配置字符编码过滤器  必须配置在所有过滤器的最前面 -->
  36.     <filter>
  37.         <filter-name>CharacterEncodingFilter</filter-name>
  38.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  39.         <init-param>
  40.             <param-name>encoding</param-name>
  41.             <param-value>UTF-8</param-value>
  42.         </init-param>
  43.         <init-param>
  44.             <param-name>forceEncoding</param-name>
  45.             <param-value>true</param-value>
  46.         </init-param>
  47.     </filter>
  49.     <filter-mapping>
  50.         <filter-name>CharacterEncodingFilter</filter-name>
  51.         <url-pattern>/*</url-pattern>
  52.     </filter-mapping>
  53.     <!--超级管理员 -->
  54.   <!-- <filter>
  55.         <filter-name>superAdminFilter</filter-name>
  56.         <filter-class>com.fxmms.filter.SuperAdminFilter</filter-class>
  57.     </filter>
  58.     <filter-mapping>
  59.         <filter-name>superAdminFilter</filter-name>
  60.         <url-pattern>/fxmms/superadmin/*</url-pattern>
  61.     </filter-mapping>
  63.     <filter>
  64.         <filter-name>adminFilter</filter-name>
  65.         <filter-class>com.fxmms.filter.AdminFilter</filter-class>
  66.     </filter>
  67.     <filter-mapping>
  68.         <filter-name>adminFilter</filter-name>
  69.         <url-pattern>/fxmms/admin/*</url-pattern>
  70.     </filter-mapping>
  72.     <filter>
  73.         <filter-name>customerFilter</filter-name>
  74.         <filter-class>com.fxmms.filter.CustomerFilter</filter-class>
  75.     </filter>
  76.     <filter-mapping>
  77.         <filter-name>customerFilter</filter-name>
  78.         <url-pattern>/fxmms/customer/*</url-pattern>
  79.     </filter-mapping>
  81.     <servlet>
  82.         <servlet-name>LoginServlet</servlet-name>
  83.         <servlet-class>com.fxmms.servlet.LoginServlet</servlet-class>
  84.     </servlet>
  85.     <servlet>
  86.         <servlet-name>InvalidateServlet</servlet-name>
  87.         <servlet-class>com.fxmms.servlet.InvalidateServlet</servlet-class>
  88.     </servlet>-
  90.     <servlet-mapping>
  91.         <servlet-name>LoginServlet</servlet-name>
  92.         <url-pattern>/loginServlet</url-pattern>
  93.     </servlet-mapping>
  94.     <servlet-mapping>
  95.     <servlet-name>InvalidateServlet</servlet-name>
  96.     <url-pattern>/invalidateServlet</url-pattern>
  97.     </servlet-mapping>-->
  99.     <!-- 配置看可以把POST请求转为PUT，DELETE请求的Filter -->
  100.     <filter>
  101.         <filter-name>HiddenHttpMethodFilter</filter-name>
  102.         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  103.     </filter>
  104.     <filter-mapping>
  105.         <filter-name>HiddenHttpMethodFilter</filter-name>
  106.         <url-pattern>/*</url-pattern>
  107.     </filter-mapping>
  108.     <!--配置中央控制器，对所有请求进行拦截并做请求路径，与处理请求桩模块之间的映射-->
  109.     <servlet>
  110.         <servlet-name>defaultDispatcherServlet</servlet-name>
  111.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  112.         <init-param>
  113.             <param-name>contextConfigLocation
  114.             </param-name>
  115.             <param-value>classpath:default-servlet.xml</param-value>
  116.         </init-param>
  117.         <load-on-startup>1</load-on-startup>
  118.     </servlet>
  119.     <!--这里是拦截所有-->
  120.     <servlet-mapping>
  121.         <servlet-name>defaultDispatcherServlet</servlet-name>
  122.         <url-pattern>/</url-pattern>
  123.     </servlet-mapping>
  124. </web-app>

2.9 build.gradle
项目构建脚本

  1. group 'com.fxmms'
  2. version '1.0-SNAPSHOT'
  4. apply plugin: 'java'
  5. apply plugin: 'idea'
  6. apply plugin: 'war'
  7. sourceCompatibility = 1.8
  9. repositories {
  10.     maven { url "http://maven.aliyun.com/nexus/content/groups/public/" }
  11.     mavenLocal()
  12.     jcenter()
  13.     maven { url "http://repo.maven.apache.org/maven2/"}
  14.     maven { url 'https://repo.spring.io/libs-milestone'}
  15.     mavenCentral()
  16. }
  18. dependencies {
  19.     testCompile group: 'junit', name: 'junit', version: '4.12'
  20.     // servlet-api
  21.     compile group: 'javax.servlet', name: 'servlet-api', version: '2.5'
  22.     //spring相关
  23.     compile group: 'org.springframework', name: 'spring-webmvc', version: '4.3.3.RELEASE'
  24.     compile group: 'org.springframework', name: 'spring-orm', version: '4.3.3.RELEASE'
  25.     compile group: 'org.springframework', name: 'spring-aspects', version: '4.3.3.RELEASE'
  26.     compile group: 'org.springframework.security', name: 'spring-security-config', version: '3.2.0.RELEASE'
  27.     compile group: 'org.springframework.security', name: 'spring-security-taglibs', version: '3.2.0.RELEASE'
  28.     compile 'org.springframework.security:spring-security-web:3.2.0.RELEASE'
  29.     //hibernate相关
  30.     compile 'org.hibernate:hibernate-core:4.3.6.Final'
  31.     //c3p0连接池
  32.     compile group: 'org.hibernate', name: 'hibernate-c3p0', version: '4.3.6.Final'
  33.     //ehcahe二级缓存
  34.     compile group: 'org.hibernate', name: 'hibernate-ehcache', version: '4.3.6.Final'
  35.     //mysql
  36.     compile group: 'mysql', name: 'mysql-connector-java', version: '5.1.39'
  37.     //springData
  38.     compile group: 'org.springframework.data', name: 'spring-data-jpa', version: '1.10.3.RELEASE'
  39.     // https://mvnrepository.com/artifact/log4j/log4j日志
  40.     compile group: 'log4j', name: 'log4j', version: '1.2.17'
  41.     //json解析相关
  42.     compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.5.4'
  43.     compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.5.4'
  44.     //迅雷接口有关jar 包
  45.     compile 'org.apache.httpcomponents:httpclient:4.4'
  46.     compile 'org.json:json:20141113'
  47.     compile group: 'org.apache.clerezza.ext', name: 'org.json.simple', version: '0.4'
  48.     //https://mvnrepository.com/artifact/org.apache.commons/commons-io 读取文件相关
  49.     compile group: 'org.apache.commons', name: 'commons-io', version: '1.3.2'
  50.     // https://mvnrepository.com/artifact/org.apache.poi/poi 文件读取相关 apache-poi
  51.     compile group: 'org.apache.poi', name: 'poi', version: '3.9'
  52.     // https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml 解决execl 版本差异
  53.     compile group: 'org.apache.poi', name: 'poi-ooxml', version: '3.9'
  54.     // https://mvnrepository.com/artifact/commons-io/commons-io 文件上传
  55.     compile group: 'commons-io', name: 'commons-io', version: '1.3.1'
  56.     // https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload
  57.     compile group: 'commons-fileupload', name: 'commons-fileupload', version: '1.2.2'
  58. }

3. 各层包功能讲解&项目搭建完毕最终效果演示图

3.1 项目中各层包功能讲解
项目中Java源代码层级结构如下图所示：

 
项目中Java源代码层级结构

对于www包中的各分层，我们对照上图重点说明：

controller:用于路由各种HTTP访问，其中可以实现对前台页面参数的对象化绑定，这个功能的实现是依赖于spring mvc中的参数绑定功能，以及返回向前端页面返回数据。也可以实现基于Restful 风格API的编写。
dao：用于实现对数据库的操作，包中的代码继承并实现自common中的dao 层代码，采用的是类的适配器模式实现的，这里的代码值得细细品味，可以说是整个项目的灵魂所在之处，稍后说明。
domain:项目中的所有实体类都存在于这个包中，其中的每个具体实体类与数据库表相对应。
dto:实现了序列化的数据传输层对象，可用于接收前台参数，前台参数被封装成dto 对象传输至后台。同时也负责对从数据库中查询数据的封装。
qo:模糊查询对象所在的包，用于封装QBC动态查询参数。
rowmapper：用于映射jdbcTemplate查询数据库返回对象的数据集，并将数据集依照以此对象为集合的实例进行封装。
schedulejob：定时任务类所在的包，在此包中的类上都要加上@Service注解，因为定时任务注解配置在service-applicationContext.xml中，包扫描组件的规则是只扫描类上有@Service注解的组件类。
service:业务逻辑层，所有的业务逻辑组件Bean都放置在这个保重，其中的类中的业务逻辑方法调用了dao实现类中的方法，并且每个有关于数据库操作的方法上都加上了@Transaction注解，用于实现对数据库操作的事务管理。@Transaction是Spring Framework对AOP 的另一种区别于拦截器的自定义注解实现。

4.项目中重要代码讲解

主要讲解一下Dao层中代码对适配器设计模式的应用：
4.1 首先看下commom层中 BaseDao.java

  1. package com.fxmms.common.dao;
  3. import com.fxmms.common.ro.Dto;
  4. import com.fxmms.common.ro.DtoResultWithPageInfo;
  5. import com.fxmms.common.ro.PageQo;
  6. import org.hibernate.Criteria;
  7. import org.springframework.stereotype.Repository;
  9. import java.io.Serializable;
  10. import java.util.List;
  11. import java.util.Map;
  13. /**
  14.  *
  15.  * @param <T>
  16.  * @usage  数据库公共操作接口
  17.  */
  18. @Repository
  19. public interface BaseDao<T> {
  21.  /**
  22.   *
  23.   *
  24.   * @param id
  25.   * @usage 根据id获取数据库中唯一纪录，封装成java对象并返回
  26.   * @return T
  27.   */
  28.  public T getById(Serializable id);
  30.  /**
  31.   *
  32.   *
  33.   * @param id
  34.   * @usage 根据id懒加载数据库中唯一纪录，封装成java对象并返回
  35.   * @return T
  36.   */
  37.  public T load(Serializable id);
  39.  /**
  40.   *
  41.   *
  42.   * @param columnName
  43.   *
  44.   * @param value
  45.   *
  46.   * @usage 根据列名，以及对应的值获取数据库中惟一纪录，封装成Java对象并返回
  47.   *
  48.   * @return
  49.   */
  50.  public T getByUniqueKey(String columnName, Object value);
  52.  /**
  53.   *
  54.   *
  55.   * @param nameValuePairs
  56.   *
  57.   * @return T
  58.   */
  59.  public T getUniqueResult(Map<String, Object> nameValuePairs);
  61.  /**
  62.   *
  63.   *
  64.   * @param columnName
  65.   *
  66.   * @param value
  67.   *
  68.   * @param sort
  69.   *
  70.   * @param order
  71.   *            asc/desc
  72.   * @return List<T>
  73.   */
  74.  public List<T> getListByColumn(String columnName, Object value,
  75.                                    String sort, String order);
  77.  public List<T> getListByColumn(String columnName, Object value);
  79.  /**
  80.   * ͨ
  81.   *
  82.   * @param nameValuePairs
  83.   *
  84.   * @param sort
  85.   *
  86.   * @param order
  87.   *            asc/desc
  88.   * @return List<T>
  89.   */
  90.  public List<T> getListByColumns(Map<String, Object> nameValuePairs,
  91.                                     String sort, String order);
  93.  public List<T> getListByColumns(Map<String, Object> nameValuePairs);
  95.  /**
  96.   *
  97.   *
  98.   * @return List<T>
  99.   */
  100.  public List<T> getAll();
  102.  /**
  103.   *
  104.   *
  105.   * @param t
  106.   * @return Serializable id
  107.   */
  108.  public Serializable save(T t);
  110.  /**
  111.   *
  112.   *
  113.   * @param t
  114.   */
  115.  public void update(T t);
  117.  /**
  118.   *
  119.   *
  120.   * @param t
  121.   */
  122.  public void delete(T t);
  124.  /**
  125.   * QBC
  126.   * @return
  127.   */
  128.  public Criteria createCriteria();
  130.  /**
  131.   * @param <E>
  132.   * @param <D>
  133.   * @param criteria
  134.   * @param pageNo
  135.   * @param pageSize
  136.   * @param dtoClazz
  137.   * @return
  138.   */
  139.  public <E, D extends Dto> DtoResultWithPageInfo<D> queryPageListByCriteria(
  140.             Criteria criteria, int pageNo, int pageSize, Class<D> dtoClazz);
  142.  /**
  143.   * @param <E>
  144.   * @param <D>
  145.   * @param criteria
  146.   * @param qo
  147.   * @param class1
  148.   * @return
  149.   */
  150.  public <E, D extends Dto> DtoResultWithPageInfo<D> queryPageListByCriteriaWithQo(PageQo qo, Class<D> dtoClazz);
  152. }

其中定义了一些对数据库的抽象公共操作方法，代码中有注释，可以对照理解。

4.2 看下HibernateTemplateDao.java对BaseDao.java的抽象实现

  1. package com.fxmms.common.dao.hib;
  3. import com.fxmms.common.dao.BaseDao;
  4. import com.fxmms.common.ro.Dto;
  5. import com.fxmms.common.ro.DtoResultWithPageInfo;
  6. import com.fxmms.common.ro.PageInfo;
  7. import com.fxmms.common.ro.PageQo;
  8. import org.apache.commons.logging.Log;
  9. import org.apache.commons.logging.LogFactory;
  10. import org.hibernate.Criteria;
  11. import org.hibernate.Session;
  12. import org.hibernate.SessionFactory;
  13. import org.hibernate.criterion.Order;
  14. import org.hibernate.criterion.Projections;
  15. import org.hibernate.criterion.Restrictions;
  16. import org.springframework.beans.BeanUtils;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.beans.factory.annotation.Qualifier;
  19. import org.springframework.stereotype.Repository;
  20. import org.springframework.util.StringUtils;
  22. import java.io.Serializable;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.Map;
  27. /**
  28.  *
  29.  * @param <T>
  30.  * @usage 应用数据访问的灵魂，抽象出各种模型类进行数据库访问的公共操作。
  31.  *        主要使用到QBC动态查询。主要思想是利用反射。
  32.  */
  33. @Repository
  34. public abstract class HibernateTemplateDao<T> implements BaseDao<T> {
  35.  protected static final Log log = LogFactory
  36.    .getLog(HibernateTemplateDao.class);
  37.     //通过反射，可以实现对不同类对应的数据表的操作
  38.  protected abstract Class<?> getEntityClass();
  40.  protected SessionFactory sessionFactory;
  42.  @Autowired
  43.  @Qualifier("sessionFactory")
  44.  public void setSessionFactory(SessionFactory sessionFactory) {
  45.   this.sessionFactory = sessionFactory;
  46.  }
  48.  public Session getSession() {
  49.   return sessionFactory.getCurrentSession();
  50.  }
  52.  public Session openNewSession() {
  53.   return sessionFactory.openSession();
  54.  }
  56.  @Override
  57.  @SuppressWarnings("unchecked")
  58.  public T getById(Serializable id) {
  59.   return (T) getSession().get(getEntityClass(), id);
  60.  }
  62.  @Override
  63.  @SuppressWarnings("unchecked")
  64.  public T getByUniqueKey(String columnName, Object value) {
  65.   return (T) getSession().createCriteria(getEntityClass())
  66.     .add(Restrictions.eq(columnName, value)).uniqueResult();
  67.  }
  69.  @Override
  70.  @SuppressWarnings("unchecked")
  71.  public List<T> getListByColumn(String columnName, Object value,String sort,String order) {
  72.   Criteria criteria = getSession().createCriteria(getEntityClass());
  73.   criteria.add(Restrictions.eq(columnName, value));
  74.   if(StringUtils.hasText(sort) && StringUtils.hasText(order)){
  75.    if("asc".equals(order)){
  76.     criteria.addOrder(Order.asc(sort));
  77.    }else if("desc".equals(order)){
  78.     criteria.addOrder(Order.desc(sort));
  79.    }
  80.   }
  81.   List<T> list = criteria.list();
  82.   return list;
  83.  }
  85.  @Override
  86.  @SuppressWarnings("unchecked")
  87.  public List<T> getListByColumn(String columnName, Object value) {
  88.   Criteria criteria = getSession().createCriteria(getEntityClass());
  89.   criteria.add(Restrictions.eq(columnName, value));
  90.   List<T> list = criteria.list();
  91.   return list;
  92.  }
  94.  @Override
  95.  @SuppressWarnings("unchecked")
  96.  public List<T> getListByColumns(Map<String, Object> nameValuePairs,String sort,String order){
  97.   Criteria criteria = getSession().createCriteria(getEntityClass());
  98.   for (Map.Entry<String, Object> entry : nameValuePairs.entrySet()) {
  99.    criteria.add(Restrictions.eq(entry.getKey(), entry.getValue()));
  100.   }
  101.   if(StringUtils.hasText(sort) && StringUtils.hasText(order)){
  102.    if("asc".equals(order)){
  103.     criteria.addOrder(Order.asc(sort));
  104.    }else if("desc".equals(order)){
  105.     criteria.addOrder(Order.desc(sort));
  106.    }
  107.   }
  108.   List<T> list = criteria.list();
  109.   return list;
  110.  }
  112.  @Override
  113.  @SuppressWarnings("unchecked")
  114.  public List<T> getListByColumns(Map<String, Object> nameValuePairs){
  115.   Criteria criteria = getSession().createCriteria(getEntityClass());
  116.   for (Map.Entry<String, Object> entry : nameValuePairs.entrySet()) {
  117.    criteria.add(Restrictions.eq(entry.getKey(), entry.getValue()));
  118.   }
  119.   List<T> list = criteria.list();
  120.   return list;
  121.  }
  122.  @Override
  123.  @SuppressWarnings("unchecked")
  124.  public List<T> getAll() {
  125.   return getSession().createCriteria(getEntityClass()).list();
  126.  }
  128.  @Override
  129.  @SuppressWarnings("unchecked")
  130.  public T getUniqueResult(Map<String, Object> nameValuePairs) {
  131.   Criteria criteria = getSession().createCriteria(getEntityClass());
  132.   for (Map.Entry<String, Object> entry : nameValuePairs.entrySet()) {
  133.    criteria.add(Restrictions.eq(entry.getKey(), entry.getValue()));
  134.   }
  135.   return (T) criteria.uniqueResult();
  136.  }
  138.  @Override
  139.  @SuppressWarnings("unchecked")
  140.  public T load(Serializable id){
  141.   return (T) getSession().load(getEntityClass(), id);
  142.  }
  144.  @Override
  145.  public Serializable save(T t) {
  146.   return getSession().save(t);
  147.  }
  149.  @Override
  150.  public void update(T t) {
  151.   Session session = this.getSession();
  152.   session.update(t);
  153.   //强制刷新缓存中数据至数据库中，防止大批量数据更新之后出现脏数据
  154.   session.flush();
  155.  }
  157.  @Override
  158.  public void delete(T t) {
  159.   this.getSession().delete(t);
  160.  }
  162.  /**
  163.   * QO  DtoResultWithPageInfo<dtoClazz>list+ҳϢ
  164.   *
  165.   * @param page
  166.   * @param pageSize
  167.   * @param qo
  168.   * @param dtoClazz
  169.   * @return
  170.   */
  171. /* public <Q extends QueryObject, D extends Dto> DtoResultWithPageInfo<D> queryPageListByQueryObject(
  172.    int page, int pageSize,Q qo, Class<D> dtoClazz){
  173.   Criteria criteria = QueryObjectHelper.buildCriteria(qo, getSession());
  174.   return queryPageListByCriteria(criteria, page, pageSize, dtoClazz);
  175.  }*/
  177.  /**
  178.   * QO List<dtoClazz>
  179.   * @param qo
  180.   * @param dtoClazz
  181.   * @return
  182.   */
  183.  /*public <Q extends QueryObject,E, D extends Dto> List<D> queryListByQueryObject(
  184.    Q qo, Class<D> dtoClazz){
  185.   Criteria criteria = QueryObjectHelper.buildCriteria(qo, getSession());
  186.   @SuppressWarnings("unchecked")
  187.   List<E> list = criteria.list();
  188.   List<D> resultsDtoList = new ArrayList<D>();
  189.   for(E entity:list){
  190.    try {
  191.     D dto = dtoClazz.newInstance();
  192.     BeanUtils.copyProperties(entity, dto);
  193.     resultsDtoList.add(dto);
  194.    } catch (InstantiationException e) {
  195.     log.error("dtoʵ쳣ExMsg==>"+e.getMessage());
  196.    } catch (IllegalAccessException e) {
  197.     log.error("dtoʵ쳣ExMsg==>"+e.getMessage());
  198.    }
  199.   }
  200.   return resultsDtoList;
  201.  }*/
  203.  /**
  204.   * queryPageListByCriteria
  205.   *
  206.   * ͨcriteria  DtoResultWithPageInfo<dtoClazz>list+ҳϢ
  207.   *
  208.   * @param criteria
  209.   *            ѯ
  210.   * @param pageNo
  211.   *            ǰҳ
  212.   * @param pageSize
  213.   *            ÿҳʾ
  214.   * @param dtoClass
  215.   *            ݴݶclass
  216.   *
  217.   */
  218.  /*public <E, D extends Dto> DtoResultWithPageInfo<D> queryPageListByCriteria(
  219.    Criteria criteria, int pageNo, int pageSize, Class<D> dtoClazz) {
  221.   PageInfo pageInfo = getInstancePageInfoWithCriteria(criteria, pageNo,
  222.     pageSize);
  223.   criteria.setProjection(null);// ͶӰ
  224.   criteria.setFirstResult(pageInfo.getFirstResultNum());
  225.   criteria.setMaxResults(pageInfo.getPageSize());
  226.   @SuppressWarnings("unchecked")
  227.   List<E> resultsList = criteria.list();
  228.   List<D> resultsDtoList = new ArrayList<D>();
  229.   for (E result : resultsList) {
  230.    D dto;
  231.    try {
  232.     dto = dtoClazz.newInstance();
  233.     try {
  234.      BeanUtils.copyProperties(result, dto);
  235.     } catch (Exception e) {
  236.      log.error("ҳѯ쳣bean쳣");
  237.      e.printStackTrace();
  238.     }
  239.    } catch (InstantiationException e) {
  240.     log.error("ҳѯ쳣dtoʼ쳣");
  241.     e.printStackTrace();
  242.     dto = null;
  243.    } catch (IllegalAccessException e) {
  244.     log.error("ҳѯ쳣dtoʼ쳣");
  245.     e.printStackTrace();
  246.     dto = null;
  247.    }
  248.    resultsDtoList.add(dto);
  249.   }
  250.   DtoResultWithPageInfo<D> resultWithPageInfo = new DtoResultWithPageInfo<D>(
  251.     resultsDtoList, pageInfo);
  252.   return resultWithPageInfo;
  253.  }*/
  255.  /**
  256.   * ͨcriteria  List<dtoClazz>
  257.   *
  258.   * @param criteria
  259.   * @param dtoClazz
  260.   * @return
  261.   */
  262.  /*public <E, D extends Dto> List<D> queryListByCriteria(
  263.    Criteria criteria,Class<D> dtoClazz) {
  265.   @SuppressWarnings("unchecked")
  266.   List<E> resultsList = criteria.list();
  267.   List<D> resultsDtoList = new ArrayList<D>();
  268.   for (E result : resultsList) {
  269.    D dto;
  270.    try {
  271.     dto = dtoClazz.newInstance();
  272.     try {
  273.      BeanUtils.copyProperties(result, dto);
  274.     } catch (Exception e) {
  275.      log.error("ҳѯ쳣bean쳣");
  276.      e.printStackTrace();
  277.     }
  278.    } catch (InstantiationException e) {
  279.     log.error("ҳѯ쳣dtoʼ쳣");
  280.     e.printStackTrace();
  281.     dto = null;
  282.    } catch (IllegalAccessException e) {
  283.     log.error("ҳѯ쳣dtoʼ쳣");
  284.     e.printStackTrace();
  285.     dto = null;
  286.    }
  287.    resultsDtoList.add(dto);
  288.   }
  289.   return resultsDtoList;
  290.  }*/
  292.  /*public DataTablePageList queryDataTablePageListByCriteria(
  293.    Criteria criteria, String displayStart, String displayLength) {
  294.   // ܼ¼
  295.   long totalRecords = 0L;
  296.   criteria.setProjection(Projections.rowCount());
  297.   totalRecords = (Long) criteria.uniqueResult();
  299.   //
  300.   criteria.setProjection(null);
  301.   criteria.setFirstResult(Integer.parseInt(displayStart));
  302.   criteria.setMaxResults(Integer.parseInt(displayLength));
  304.   @SuppressWarnings("rawtypes")
  305.   List resultsList = criteria.list();
  307.   DataTablePageList dtpl = new DataTablePageList(
  308.     String.valueOf((int) totalRecords), resultsList);
  309.   return dtpl;
  310.  }
  311.  */
  313.  /**
  314.   * ͨѯʼҳϢ
  315.   *
  316.   * @param criteria
  317.   * @param pageNo
  318.   * @param pageSize
  319.   * @return
  320.   *//*
  321.  private PageInfo getInstancePageInfoWithCriteria(Criteria criteria,
  322.    int pageNo, int pageSize) {
  323.   long totalQuantity = 0L;
  324.   criteria.setProjection(Projections.rowCount());
  325.   totalQuantity = (Long) criteria.uniqueResult();
  326.   PageInfo pageInfo = PageInfo.getInstance(pageNo, pageSize,
  327.     totalQuantity);
  328.   return pageInfo;
  329.  }*/
  331.  @Override
  332.  public Criteria createCriteria() {
  333.   // TODO Auto-generated method stub
  334.   return getSession().createCriteria(getEntityClass());
  335.  }
  337.  /**
  338.   * queryPageListByCriteria
  339.   *
  340.   * ͨcriteria  DtoResultWithPageInfo<dtoClazz>list+ҳϢ
  341.   *
  342.   * @param criteria
  343.   *            ѯ
  344.   * @param pageNo
  345.   *            ǰҳ
  346.   * @param pageSize
  347.   *            ÿҳʾ
  348.   * @param dtoClass
  349.   *            ݴݶclass
  350.   * ص DtoResultWithPageInfo
  351.   *
  352.   * Ϊ queryPageListByCriteria
  353.   */
  354.  @Override
  355.  public <E, D extends Dto> DtoResultWithPageInfo<D> queryPageListByCriteria(
  356.    Criteria criteria, int pageNo, int pageSize, Class<D> dtoClazz) {
  357.       //˷ĵãpageinfoѾfirstResult  maxresult
  358.   PageInfo pageInfo = getInstancePageInfoWithCriteria(criteria, pageNo,
  359.     pageSize);
  361.   criteria.setProjection(null);// ͶӰ
  362.   criteria.setFirstResult(pageInfo.getFirstResultNum());
  363.   criteria.setMaxResults(pageInfo.getPageSize());
  364.   @SuppressWarnings("unchecked")
  365.   List<E> resultsList = criteria.list();
  366.   List<D> resultsDtoList = new ArrayList<D>();
  367.   for (E result : resultsList) {
  368.    D dto;
  369.    try {
  370.     dto = dtoClazz.newInstance();
  371.     try {
  372.      BeanUtils.copyProperties(result, dto);
  373.     } catch (Exception e) {
  374.      log.error("ҳѯ쳣bean쳣");
  375.      e.printStackTrace();
  376.     }
  377.    } catch (InstantiationException e) {
  378.     log.error("ҳѯ쳣dtoʼ쳣");
  379.     e.printStackTrace();
  380.     dto = null;
  381.    } catch (IllegalAccessException e) {
  382.     log.error("ҳѯ쳣dtoʼ쳣");
  383.     e.printStackTrace();
  384.     dto = null;
  385.    }
  386.    resultsDtoList.add(dto);
  387.   }
  388.   DtoResultWithPageInfo<D> resultWithPageInfo = new DtoResultWithPageInfo<D>(
  389.     resultsDtoList, pageInfo);
  390.   return resultWithPageInfo;
  391.  }
  393.  /**
  394.   * queryPageListByCriteriaWithQo
  395.   *
  396.   * ͨcriteria  DtoResultWithPageInfo<dtoClazz>list+ҳϢ
  397.   *
  398.   * @param criteria
  399.   *            ѯ
  400.   * @param pageNo
  401.   *            ǰҳ
  402.   * @param pageSize
  403.   *            ÿҳʾ
  404.   * @param dtoClass
  405.   *            ݴݶclass
  406.   * ص DtoResultWithPageInfo
  407.   *
  408.   * Ϊ queryPageListByCriteria
  409.   */
  410.  @Override
  411.  public <E, D extends Dto> DtoResultWithPageInfo<D> queryPageListByCriteriaWithQo(PageQo qo, Class<D> dtoClazz) {
  412.       //˷ĵãpageinfoѾfirstResult  maxresult
  413.   Criteria criteria = this.createCriteria();
  414.   qo.add(criteria);
  415.   PageInfo pageInfo = getInstancePageInfoWithCriteria(criteria, qo.getPage(),qo.getRows());
  417.   criteria.setProjection(null);// ͶӰ
  418.   criteria.setFirstResult(pageInfo.getFirstResultNum());
  419.   criteria.setMaxResults(pageInfo.getPageSize());
  420.   @SuppressWarnings("unchecked")
  421.   List<E> resultsList = criteria.list();
  422.   List<D> resultsDtoList = new ArrayList<D>();
  423.   for (E result : resultsList) {
  424.    D dto;
  425.    try {
  426.     dto = dtoClazz.newInstance();
  427.     try {
  428.      BeanUtils.copyProperties(result, dto);
  429.     } catch (Exception e) {
  430.      log.error("ҳѯ쳣bean쳣");
  431.      e.printStackTrace();
  432.     }
  433.    } catch (InstantiationException e) {
  434.     log.error("ҳѯ쳣dtoʼ쳣");
  435.     e.printStackTrace();
  436.     dto = null;
  437.    } catch (IllegalAccessException e) {
  438.     log.error("ҳѯ쳣dtoʼ쳣");
  439.     e.printStackTrace();
  440.     dto = null;
  441.    }
  442.    resultsDtoList.add(dto);
  443.   }
  444.   DtoResultWithPageInfo<D> resultWithPageInfo = new DtoResultWithPageInfo<D>(
  445.     resultsDtoList, pageInfo);
  446.   return resultWithPageInfo;
  447.  }
  449.  /**
  450.   * ͨѯʼҳϢ
  451.   *
  452.   * @param criteria
  453.   * @param pageNo
  454.   * @param pageSize
  455.   * @return
  456.   */
  457.  private PageInfo getInstancePageInfoWithCriteria(Criteria criteria,
  458.   int pageNo, int pageSize) {
  459.    long totalQuantity = 0L;
  460.          //  ܵtotalQuality
  461.   criteria.setProjection(Projections.rowCount());
  462.   totalQuantity = (Long) criteria.uniqueResult();
  464.   PageInfo pageInfo = PageInfo.getInstance(pageNo, pageSize,
  465.     totalQuantity);
  466.   return pageInfo;
  467.  }
  468. }

这个方法是极为重要的 protected abstract Class<?> getEntityClass();
后续介绍，现在暂时有个印象。
在www中的dao层有与各具体类(数据表)相对应的数据库操作实现：

 
屏幕快照 2016-11-20 下午11.22.30.png

上图声明了三个具体类对应的接口声明：AdminDao、MacDao、TaskDao。
对应三个接口有三个具体的实现类：AdminDaoImpl、MacDaoImpl、TaskDaoImpl。
我们以与Admin类相关的dao层操作为例：
Admin.java

  1. package com.fxmms.www.domain;
  3. import org.hibernate.annotations.GenericGenerator;
  5. import javax.persistence.*;
  7. /**
  8.  * Created by mark on 16/11/2.
  9.  * @usage 管理员实体类，与数据库中表相对应
  10.  */
  11. @Entity
  12. @Table(name = "mms_admin")
  13. public class Admin {
  14.     @Id
  15.     @GeneratedValue(generator = "increment")
  16.     @GenericGenerator(name = "increment", strategy = "increment")
  17.     @Column
  18.     private int id;
  19.     @Column
  20.     private String userName;
  21.     @Column
  22.     private String password;
  23.     @Column
  24.     private String role;
  25.     @Column
  26.     private int enable;
  27.     @Column
  28.     private int isDelete;
  30.     public int getId() {
  31.         return id;
  32.     }
  34.     public void setId(int id) {
  35.         this.id = id;
  36.     }
  38.     public String getUserName() {
  39.         return userName;
  40.     }
  42.     public void setUserName(String userName) {
  43.         this.userName = userName;
  44.     }
  46.     public String getPassword() {
  47.         return password;
  48.     }
  50.     public void setPassword(String password) {
  51.         this.password = password;
  52.     }
  54.     public String getRole() {
  55.         return role;
  56.     }
  58.     public void setRole(String role) {
  59.         this.role = role;
  60.     }
  62.     public int getEnable() {
  63.         return enable;
  64.     }
  66.     public void setEnable(int enable) {
  67.         this.enable = enable;
  68.     }
  70.     public int getIsDelete() {
  71.         return isDelete;
  72.     }
  74.     public void setIsDelete(int isDelete) {
  75.         this.isDelete = isDelete;
  76.     }
  77. }

AdminDao.java

  1. package com.fxmms.www.dao;
  3. import com.fxmms.common.dao.BaseDao;
  4. import com.fxmms.www.domain.Admin;
  6. /**
  7.  * Created by mark on 16/10/31.
  8.  * @usage 操作管理员数据库访问接口
  9.  */
  10. public interface AdminDao extends BaseDao<Admin> {
  12. }

AdminDaoImpl.java

  1. package com.fxmms.www.dao.hib;
  3. import com.fxmms.common.dao.hib.HibernateTemplateDao;
  4. import com.fxmms.www.dao.AdminDao;
  5. import com.fxmms.www.domain.Admin;
  7. /**
  8.  * Created by mark on 16/11/2.
  9.  * @usage 使用适配器模式，将common层中定义的公共访问数据库方法实现嫁接到Admin类的接口中。
  10.  */
  11. public class AdminDaoImpl extends HibernateTemplateDao<Admin> implements AdminDao {
  13.     @Override
  14.     protected Class<?> getEntityClass() {
  15.         // TODO Auto-generated method stub
  16.         return Admin.class;
  17.     }
  18. }

可以看到，在具体类相关的数据库操作实现类中，我们只需要实现HibernateTemplateDao<T>中抽象方法protected Class<?> getEntityClass()；即可。
给我们的感觉就是这个方法的实现是画龙点睛之笔。
回过头去看，在HibernateTemplateDao类中所有与数据库操作有关的方法：
例如：

  1.  @Override
  2.  @SuppressWarnings("unchecked")
  3.  public T getByUniqueKey(String columnName, Object value) {
  4.   return (T) getSession().createCriteria(getEntityClass())
  5.     .add(Restrictions.eq(columnName, value)).uniqueResult();
  6.  }

getEntityClass()方法最终都会被具体的类所实现。这个设计真的是很巧妙。

5.webapp文件夹下分层详解

webapp下有res文件夹，用于存储静态文件，WEB-INF文件夹下有view文件夹用于放置应用中jsp页面。
文件组织结构如下图所示：

 
webapp下静态资源以及前端页面

6.配置tomcat 运行环境

项目搭建已经完毕，接下来需要做的就是配置项目的运行环境了，这里我们采用tomcat来充当应用服务器。
6.1 去官网下载tomcat 8.0：http://tomcat.apache.org/download-80.cgi
6.2 配置 tomcat 服务器：
点击Edit Configurations

 
屏幕快照 2016-11-20 下午11.48.58.png

点击+,并选择Tomcat Server中local选项

 
屏幕快照 2016-11-20 下午11.51.03.png

添加启动任务名称，默认为unnamed

 
屏幕快照 2016-11-21 上午9.33.39.png

配置Application Server

 
屏幕快照 2016-11-21 上午9.39.06.png

装载开发版(exploded)应用war包,此步骤有两种方式：
第一种方式：选择Deploy at the server startup下方的+，入下图所示：

 
屏幕快照 2016-11-21 上午9.54.16.png

接下来在Select Artifacts Deploy 弹出框中 选择 exploded 属性的war包

 
屏幕快照 2016-11-21 上午9.54.31.png

接下来选择apply－> ok ，最终的结果是：

 
屏幕快照 2016-11-21 上午10.05.46.png
 
屏幕快照 2016-11-21 上午10.12.55.png

最终点击启动按钮启动应用

 
屏幕快照 2016-11-21 上午10.15.46.png

最终的启动效果如下所示

 
  1.  

Java 本地开发环境搭建（框架采用 Spring+Spring MVC+Hibernate+Jsp+Gradle＋tomcat+mysql5.6）的更多相关文章

  1. （转载）JAVA敏捷开发环境搭建

    整个软件项目分为四个环境 开发本地环境.开发环境.测试环境.IDC环境.和传统C++开发不一样的模式是多了第一个开发本地环境.这是为什么呢,因为目前大部分开发人员还是比较熟悉windows下开发.对于 ...

  2. Java基本开发环境搭建(适合第一次使用)

    Java基本开发环境搭建(适合第一次使用) 编写人:cc 阿爸 2013-10-17 一.开发工具获取 1.开发工具包JDK l  下载地址: 到ORACLE公司官方网站(http://www.ora ...

  3. spark-windows（含eclipse配置）下本地开发环境搭建

    spark-windows(含eclipse配置)下本地开发环境搭建   >>>>>>注意:这里忽略JDK的安装,JDK要求是1.8及以上版本,请通过 java  ...

  4. JAVA WEB开发环境搭建

    JAVA WED开发环境搭建 JDK的安装和配置 到https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-21 ...

  5. Java 学习笔记 第一章：Java语言开发环境搭建

    第一章:Java语言开发环境搭建 第二章:常量.变量和数据类型 第三章:数据类型转换.运算符和方法入门 1.Java虚拟机——JVM JVM(Java Virtual Machine ):Java虚拟 ...

  6. 手把手教你 Apache DolphinScheduler 本地开发环境搭建 | 中英文视频教程

    点击上方 蓝字关注我们 最近,一些小伙伴反馈对小海豚的本地开发环境搭建过程不太了解,这不就有活跃的贡献者送来新鲜的视频教程!在此感谢@Tianqi-Dotes 的细致讲解 贡献者还贴心地录制了中英文两 ...

  7. （转）微信公众平台开发之基于百度 BAE3.0 的开发环境搭建（采用 Baidu Eclipse）

    原文传送门(http://blog.csdn.net/bingtianxuelong/article/details/17843111) 版本说明:     V1:         2014-2-13 ...

  8. 【OpenStack】OpenStack系列1之OpenStack本地开发环境搭建&&向社区贡献代码

    加入OpenStack社区 https://launchpad.net/,注册用户(597092663@qq.com/Admin@123) 修改个人信息,配置SSH keys.OpenPGP keys ...

  9. Mac OS X上IntelliJ IDEA 13与Tomcat 8的Java Web开发环境搭建

    这标题实在有点拗口,不知道怎么写好,但看了标题也就明白文本的内容.最近几天在折腾这些玩意儿,所以写写总结.除了环境搭建,本文还是一篇入门级的上手教程. 去下载一些东西 JDK安装 Tomcat安装 T ...

随机推荐

  1. Bootstrap里的文件分别表示什么？都有什么用？

    bootstrap.css 是完整的bootstrap样式表,未经压缩过的,可供开发的时候进行调试用bootstrap.min.css 是经过压缩后的bootstrap样式表,内容和bootstrap ...

  2. C#winform程序安装在默认路径提示权限不足的问题

    这个需要以管理员身份运行即可.在program.cs里面修改即可也可以在别的地方,如:C# 编程中可以使程序自动使用管理员身份运行,也就是我们常常看到一些程序的图标上会冒出个盾牌.方法:在源码的Pro ...

  3. AFNetworking提示3840 Unescaped control character around character XXX

    处理办法:找到AFNetworking包中AFURLResponseSerialization.m文件在第250行修改代码如下: if (data.length > 0 && ! ...

  4. Python中的列表生成器，迭代器的理解

    首先,思考一个问题,比如,我们想生成0-100的列表,我们怎么做? 当然,可以写成 list1=[1,2,3...,100] 可以看出,这种方法不适合生成长的列表,那么Python中就可以利用已有的列 ...

  5. Javascript 数组（Array）相关内容总结

    创建数组 var colors = new Array(); //创建新数组 var num = new Array(3); //创建包含三项的新数组 var names = new Array(&q ...

  6. spring mvc 复杂参数注入

    过了这么久,又重新把博客拾起来了 来上海工作也已经有将近两周的时间了, 今天在整理项目的时候,遇到了一个关于参数注入的问题 背景: 我的开发前台用的是extjs4,在对后台spring mvc提交表单 ...

  7. PHP 静态缓存

    今天来说说PHP页面的静态缓存. 根据个人理解,由于客户端重复的请求某个页面,导致该页面短时间内被重复请求相同的数据,导致给服务端一定的压力,同时用户访问速度也会变慢.此时如果把这个页面缓存起来,客户 ...

  8. wkhtmltopdf

    最近要做一个html转pdf的功能,在网上找了很多内容,itext什么的,都不太满意,最后找到一个wkhtmltopdf,用起来真的很不错,还找到了一篇好文章,我就直接抄过来了,等有时间我再自己理一遍 ...

  9. apply/call/bind的区别与用法

    apply 方法/call 方法 obj.call(thisObj, arg1, arg2, ...);obj.apply(thisObj, [arg1, arg2, ...]); 两者作用一致,都是 ...

  10. C++ queue deque

    queue queue 队,一种先进先出的数据结构,c++ stl里也叫容器适配器,它是以deque 或list为基础的一种数据结构 queue的相关操作 queue<int deque< ...