基于Spring + Spring MVC + Mybatis 高性能web构建

来源：互联网发布：淘宝联盟活动推广编辑：程序博客网时间：2024/06/02 05:29

转自：http://blog.csdn.net/zoutongyuan/article/details/41379851

基于Spring + Spring MVC + Mybatis 高性能web构建

一直想写这篇文章，前段时间痴迷于JavaScript、NodeJs、AngularJs，做了大量的研究，对前后端交互有了更深层次的认识。

今天抽个时间写这篇文章，我有预感，这将是一篇很详细的文章，详细的配置，详细的注释，看起来应该很容易懂。

用最合适的技术去实现，并不断追求最佳实践。这就是架构之道。

希望这篇文章能给你们带来一些帮助，同时希望你们可以为这个项目贡献你的想法。

源码地址：https://github.com/starzou/quick4j 点击打开

看我们的项目结构：

是一个典型的Maven 项目：

src/main/java：存放java源文件
src/main/resources：存放程序资源、配置文件
src/test/java：存放测试代码文件
src/main/webapp：web根目录
pom.xml ： maven项目配置文件，管理依赖，编译，打包

主要的后端架构：Spring + Spring MVC + Mybatis + Apache Shiro

前端界面主要使用MetroNic 模板,

先看我们搭建完成，跑起来的效果，这样你才有兴趣看下去：

你可以在github 上 checkout quick4j项目查看，并跟下面步骤来搭建：

强烈建议你，checkout https://github.com/starzou/quick4j ，在本地跑起来，再试着自己搭建框架

1、首先创建 maven 项目，用 idea 、eclipse 或 mvn 命令行都行

2、配置 pom.xml ，添加框架依赖

[html] view plaincopyprint?
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
    <modelVersion>4.0.0</modelVersion>  
    <groupId>com.eliteams</groupId>  
    <artifactId>quick4j</artifactId>  
    <packaging>war</packaging>  
    <version>1.0.0</version>  
    <name>quick4j App</name>  
    <url>https://github.com/starzou/quick4j</url>  
  
    <build>  
        <finalName>quick4j</finalName>  
        <plugins>  
            <!-- Mybatis generator代码生成插件 配置 -->  
            <plugin>  
                <groupId>org.mybatis.generator</groupId>  
                <artifactId>mybatis-generator-maven-plugin</artifactId>  
                <version>${plugin.mybatis.generator}</version>  
                <configuration>  
                    <configurationFile>${mybatis.generator.generatorConfig.xml}</configurationFile>  
                    <overwrite>true</overwrite>  
                    <verbose>true</verbose>  
                </configuration>  
            </plugin>  
  
            <!--Maven编译插件 配置-->  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <version>${plugin.maven-compiler}</version>  
                <configuration>  
                    <source>${project.build.jdk}</source>  
                    <target>${project.build.jdk}</target>  
                    <encoding>${project.build.sourceEncoding}</encoding>  
                </configuration>  
            </plugin>  
        </plugins>  
  
        <!--配置Maven 对resource文件 过滤 -->  
        <resources>  
            <resource>  
                <directory>src/main/resources</directory>  
                <includes>  
                    <include>**/*.properties</include>  
                    <include>**/*.xml</include>  
                </includes>  
                <filtering>true</filtering>  
            </resource>  
            <resource>  
                <directory>src/main/java</directory>  
                <includes>  
                    <include>**/*.properties</include>  
                    <include>**/*.xml</include>  
                </includes>  
                <filtering>true</filtering>  
            </resource>  
        </resources>  
    </build>  
  
    <properties>  
        <!-- base setting -->  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
        <project.build.locales>zh_CN</project.build.locales>  
        <project.build.jdk>1.7</project.build.jdk>  
  
        <!-- plugin setting -->  
        <mybatis.generator.generatorConfig.xml>${basedir}/src/test/resources/generatorConfig.xml</mybatis.generator.generatorConfig.xml>  
        <mybatis.generator.generatorConfig.properties>file:///${basedir}/src/test/resources/generatorConfig.properties</mybatis.generator.generatorConfig.properties>  
  
        <!-- plugin versions -->  
        <plugin.mybatis.generator>1.3.1</plugin.mybatis.generator>  
        <plugin.maven-compiler>3.1</plugin.maven-compiler>  
  
        <!-- lib versions -->  
        <junit.version>4.11</junit.version>  
        <spring.version>4.0.2.RELEASE</spring.version>  
        <mybatis.version>3.2.2</mybatis.version>  
        <mybatis.spring.version>1.2.2</mybatis.spring.version>  
        <mysql.connector.version>5.1.30</mysql.connector.version>  
        <postgresql.version>9.1-901.jdbc4</postgresql.version>  
        <slf4j.version>1.6.6</slf4j.version>  
        <log4j.version>1.2.12</log4j.version>  
        <httpclient.version>4.1.2</httpclient.version>  
        <jackson.version>1.9.13</jackson.version>  
        <c3p0.version>0.9.1.2</c3p0.version>  
        <druid.version>1.0.5</druid.version>  
        <tomcat.jdbc.version>7.0.53</tomcat.jdbc.version>  
        <jstl.version>1.2</jstl.version>  
        <google.collections.version>1.0</google.collections.version>  
        <cglib.version>3.1</cglib.version>  
        <shiro.version>1.2.3</shiro.version>  
        <commons.fileupload.version>1.3.1</commons.fileupload.version>  
        <commons.codec.version>1.9</commons.codec.version>  
        <commons.net.version>3.3</commons.net.version>  
        <aspectj.version>1.6.12</aspectj.version>  
        <netty.version>4.0.18.Final</netty.version>  
        <hibernate.validator.version>5.1.1.Final</hibernate.validator.version>  
    </properties>  
  
    <dependencies>  
        <!-- junit -->  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>${junit.version}</version>  
        </dependency>  
  
        <!-- springframe start -->  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-core</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-web</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-oxm</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-tx</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-jdbc</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-webmvc</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-aop</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-test</artifactId>  
            <version>${spring.version}</version>  
        </dependency>  
        <!-- springframe end -->  
  
        <!-- mybatis start-->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>${mybatis.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version>${mybatis.spring.version}</version>  
        </dependency>  
        <!--mybatis end-->  
  
        <!-- mysql-connector -->  
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>${mysql.connector.version}</version>  
        </dependency>  
  
        <!-- DruidDataSource -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>druid</artifactId>  
            <version>${druid.version}</version>  
        </dependency>  
  
        <!-- jackson -->  
        <dependency>  
            <groupId>org.codehaus.jackson</groupId>  
            <artifactId>jackson-mapper-asl</artifactId>  
            <version>${jackson.version}</version>  
        </dependency>  
  
        <!-- log start -->  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-log4j12</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
        <!-- log end -->  
  
        <!-- servlet api -->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>  
            <version>3.0.1</version>  
            <scope>provided</scope>  
        </dependency>  
  
        <!-- jstl -->  
        <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>  
            <version>${jstl.version}</version>  
        </dependency>  
  
        <!-- start apache -->  
        <dependency>  
            <groupId>commons-fileupload</groupId>  
            <artifactId>commons-fileupload</artifactId>  
            <version>${commons.fileupload.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.apache.httpcomponents</groupId>  
            <artifactId>httpclient</artifactId>  
            <version>${httpclient.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>commons-codec</groupId>  
            <artifactId>commons-codec</artifactId>  
            <version>${commons.codec.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>commons-net</groupId>  
            <artifactId>commons-net</artifactId>  
            <version>${commons.net.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>commons-logging</groupId>  
            <artifactId>commons-logging</artifactId>  
            <version>1.1.3</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-collections</groupId>  
            <artifactId>commons-collections</artifactId>  
            <version>3.2.1</version>  
        </dependency>  
  
        <!-- end apache -->  
  
        <!-- google -->  
        <dependency>  
            <groupId>com.google.collections</groupId>  
            <artifactId>google-collections</artifactId>  
            <version>${google.collections.version}</version>  
        </dependency>  
  
        <!-- cglib -->  
        <dependency>  
            <groupId>cglib</groupId>  
            <artifactId>cglib-nodep</artifactId>  
            <version>${cglib.version}</version>  
        </dependency>  
  
  
        <!-- shiro -->  
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-spring</artifactId>  
            <version>${shiro.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-ehcache</artifactId>  
            <version>${shiro.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-core</artifactId>  
            <version>${shiro.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-web</artifactId>  
            <version>${shiro.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.apache.shiro</groupId>  
            <artifactId>shiro-quartz</artifactId>  
            <version>${shiro.version}</version>  
        </dependency>  
  
        <!-- aspectjweaver -->  
        <dependency>  
            <groupId>org.aspectj</groupId>  
            <artifactId>aspectjweaver</artifactId>  
            <version>${aspectj.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.aspectj</groupId>  
            <artifactId>aspectjrt</artifactId>  
            <version>${aspectj.version}</version>  
        </dependency>  
  
        <!-- hibernate-validator -->  
        <dependency>  
            <groupId>org.hibernate</groupId>  
            <artifactId>hibernate-validator</artifactId>  
            <version>${hibernate.validator.version}</version>  
        </dependency>  
  
        <!-- netty -->  
        <dependency>  
            <groupId>io.netty</groupId>  
            <artifactId>netty-all</artifactId>  
            <version>${netty.version}</version>  
        </dependency>  
  
        <dependency>  
            <groupId>org.mybatis.generator</groupId>  
            <artifactId>mybatis-generator-core</artifactId>  
            <version>1.3.2</version>  
            <type>jar</type>  
            <scope>test</scope>  
        </dependency>  
  
    </dependencies>  
</project>  

3、配置web.xml

web.xml是一个项目的核心，看看它的一些配置：
配置 ContextLoaderListener 监听器
配置Spring字符编码过滤器
配置shiro 安全过滤器
配置Spring MVC 核心控制器 DispatcherServlet
配置一些页面

spring 和 apache shiro 是由一个 ContextLoaderListener 监听器加载的配置文件，并初始化

[html] view plaincopyprint?
<?xml version="1.0" encoding="utf-8"?>  
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" version="2.4" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
    <!-- Spring -->  
    <!-- 配置Spring配置文件路径 -->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>  
            classpath*:applicationContext.xml  
            classpath*:applicationContext-shiro.xml  
        </param-value>  
    </context-param>  
    <!-- 配置Spring上下文监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <!-- Spring -->  
  
    <!-- 配置Spring字符编码过滤器 -->  
    <filter>  
        <filter-name>encodingFilter</filter-name>  
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
        <init-param>  
            <param-name>encoding</param-name>  
            <param-value>UTF-8</param-value>  
        </init-param>  
        <init-param>  
            <param-name>forceEncoding</param-name>  
            <param-value>true</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>encodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
  
    <!-- shiro 安全过滤器 -->  
    <filter>  
        <filter-name>shiroFilter</filter-name>  
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>  
        <async-supported>true</async-supported>  
        <init-param>  
            <param-name>targetFilterLifecycle</param-name>  
            <param-value>true</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>shiroFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
  
    <!-- 配置log4j配置文件路径 -->  
    <context-param>  
        <param-name>log4jConfigLocation</param-name>  
        <param-value>classpath:log4j.properties</param-value>  
    </context-param>  
    <!-- 60s 检测日志配置 文件变化 -->  
    <context-param>  
        <param-name>log4jRefreshInterval</param-name>  
        <param-value>60000</param-value>  
    </context-param>  
  
    <!-- 配置Log4j监听器 -->  
    <listener>  
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
    </listener>  
  
    <!-- Spring MVC 核心控制器 DispatcherServlet 配置 -->  
    <servlet>  
        <servlet-name>dispatcher</servlet-name>  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <param-value>classpath*:spring-mvc.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup>  
    </servlet>  
    <servlet-mapping>  
        <servlet-name>dispatcher</servlet-name>  
        <!-- 拦截所有/rest/* 的请求,交给DispatcherServlet处理,性能最好 -->  
        <url-pattern>/rest/*</url-pattern>  
    </servlet-mapping>  
  
    <!-- 首页 -->  
    <welcome-file-list>  
        <welcome-file>rest/index</welcome-file>  
    </welcome-file-list>  
  
    <!-- 错误页 -->  
    <error-page>  
        <error-code>404</error-code>  
        <location>/rest/page/404</location>  
    </error-page>  
    <error-page>  
        <error-code>500</error-code>  
        <location>/rest/page/500</location>  
    </error-page>  
    <error-page>  
        <exception-type>org.apache.shiro.authz.AuthorizationException</exception-type>  
        <location>/rest/page/401</location>  
    </error-page>  
  
</web-app>  

4、spring配置：

applicationContext.xml

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"  
       xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
       xmlns:cache="http://www.springframework.org/schema/cache"  
       xsi:schemaLocation="  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/tx  
    http://www.springframework.org/schema/tx/spring-tx.xsd  
    http://www.springframework.org/schema/jdbc  
    http://www.springframework.org/schema/jdbc/spring-jdbc.xsd  
    http://www.springframework.org/schema/cache  
    http://www.springframework.org/schema/cache/spring-cache.xsd  
    http://www.springframework.org/schema/aop  
    http://www.springframework.org/schema/aop/spring-aop.xsd  
    http://www.springframework.org/schema/util  
    http://www.springframework.org/schema/util/spring-util.xsd">  
  
    <!-- 自动扫描quick4j包 ,将带有注解的类 纳入spring容器管理 -->  
    <context:component-scan base-package="com.eliteams.quick4j"></context:component-scan>  
  
    <!-- 引入配置文件 -->  
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="locations">  
            <list>  
                <value>classpath*:application.properties</value>  
            </list>  
        </property>  
    </bean>  
  
    <!-- dataSource 配置 -->  
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
        <!-- 基本属性 url、user、password -->  
        <property name="url" value="${jdbc.url}"/>  
        <property name="username" value="${jdbc.username}"/>  
        <property name="password" value="${jdbc.password}"/>  
  
        <!-- 配置初始化大小、最小、最大 -->  
        <property name="initialSize" value="${ds.initialSize}"/>  
        <property name="minIdle" value="${ds.minIdle}"/>  
        <property name="maxActive" value="${ds.maxActive}"/>  
  
        <!-- 配置获取连接等待超时的时间 -->  
        <property name="maxWait" value="${ds.maxWait}"/>  
  
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->  
        <property name="timeBetweenEvictionRunsMillis" value="${ds.timeBetweenEvictionRunsMillis}"/>  
  
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->  
        <property name="minEvictableIdleTimeMillis" value="${ds.minEvictableIdleTimeMillis}"/>  
  
        <property name="validationQuery" value="SELECT 'x'"/>  
        <property name="testWhileIdle" value="true"/>  
        <property name="testOnBorrow" value="false"/>  
        <property name="testOnReturn" value="false"/>  
  
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->  
        <property name="poolPreparedStatements" value="false"/>  
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>  
  
        <!-- 配置监控统计拦截的filters -->  
        <property name="filters" value="stat"/>  
    </bean>  
  
    <!-- mybatis文件配置，扫描所有mapper文件 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" p:dataSource-ref="dataSource"  
          p:configLocation="classpath:mybatis-config.xml"  
          p:mapperLocations="classpath:com/eliteams/quick4j/web/dao/*.xml"/>  
  
    <!-- spring与mybatis整合配置，扫描所有dao -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" p:basePackage="com.eliteams.quick4j.web.dao"  
          p:sqlSessionFactoryBeanName="sqlSessionFactory"/>  
  
    <!-- 对dataSource 数据源进行事务管理 -->  
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"  
          p:dataSource-ref="dataSource"/>  
  
    <!-- 事务管理 通知 -->  
    <tx:advice id="txAdvice" transaction-manager="transactionManager">  
        <tx:attributes>  
            <!-- 对insert,update,delete 开头的方法进行事务管理,只要有异常就回滚 -->  
            <tx:method name="insert*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>  
            <tx:method name="update*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>  
            <tx:method name="delete*" propagation="REQUIRED" rollback-for="java.lang.Throwable"/>  
            <!-- select,count开头的方法,开启只读,提高数据库访问性能 -->  
            <tx:method name="select*" read-only="true"/>  
            <tx:method name="count*" read-only="true"/>  
            <!-- 对其他方法 使用默认的事务管理 -->  
            <tx:method name="*"/>  
        </tx:attributes>  
    </tx:advice>  
  
    <!-- 事务 aop 配置 -->  
    <aop:config>  
        <aop:pointcut id="serviceMethods" expression="execution(* com.eliteams.quick4j.web.service..*(..))"/>  
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>  
    </aop:config>  
  
    <!-- 配置使Spring采用CGLIB代理 -->  
    <aop:aspectj-autoproxy proxy-target-class="true"/>  
  
    <!-- 启用对事务注解的支持 -->  
    <tx:annotation-driven transaction-manager="transactionManager"/>  
  
    <!-- Cache配置 -->  
    <cache:annotation-driven cache-manager="cacheManager"/>  
    <bean id="ehCacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"  
          p:configLocation="classpath:ehcache.xml"/>  
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"  
          p:cacheManager-ref="ehCacheManagerFactory"/>  
</beans>  

application.properties

[plain] view plaincopyprint?
##JDBC Global Setting  
jdbc.driver=com.mysql.jdbc.Driver  
jdbc.url=jdbc:mysql://localhost:3306/quick4j?useUnicode=true&characterEncoding=utf-8  
jdbc.username=root  
jdbc.password=admin123  
  
##DataSource Global Setting  
  
#配置初始化大小、最小、最大  
ds.initialSize=1  
ds.minIdle=1  
ds.maxActive=20  
  
#配置获取连接等待超时的时间   
ds.maxWait=60000  
  
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒  
ds.timeBetweenEvictionRunsMillis=60000  
  
#配置一个连接在池中最小生存的时间，单位是毫秒  
ds.minEvictableIdleTimeMillis=300000  

ehcache.xml

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8"?>  
<ehcache updateCheck="false" name="txswx-ehcache">  
    <diskStore path="java.io.tmpdir"/>  
    <!-- DefaultCache setting. -->  
    <defaultCache maxEntriesLocalHeap="10000" eternal="true" timeToIdleSeconds="300" timeToLiveSeconds="600"  
                  overflowToDisk="true" maxEntriesLocalDisk="100000"/>  
</ehcache>  

5、Apache Shiro 配置：要配置realms bean

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:util="http://www.springframework.org/schema/util"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xsi:schemaLocation="  
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">  
  
    <description>apache shiro配置</description>  
  
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">  
        <property name="securityManager" ref="securityManager"/>  
        <property name="loginUrl" value="/rest/page/login"/>  
        <property name="successUrl" value="/rest/index"/>  
        <property name="unauthorizedUrl" value="/rest/page/401"/>  
        <property name="filterChainDefinitions">  
            <value>  
                <!-- 静态资源允许访问 -->  
                /app/** = anon  
                /assets/** = anon  
                <!-- 登录页允许访问 -->  
                /rest/user/login = anon  
                <!-- 其他资源需要认证 -->  
                /** = authc  
            </value>  
        </property>  
    </bean>  
  
    <!-- 缓存管理器 使用Ehcache实现 -->  
    <bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">  
        <property name="cacheManagerConfigFile" value="classpath:ehcache-shiro.xml"/>  
    </bean>  
  
    <!-- 会话DAO -->  
    <bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.MemorySessionDAO"/>  
  
    <!-- 会话管理器 -->  
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">  
        <property name="sessionDAO" ref="sessionDAO"/>  
    </bean>  
  
    <!-- 安全管理器 -->  
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">  
        <property name="realms">  
            <list>  
                <ref bean="securityRealm"/>  
            </list>  
        </property>  
        <!-- cacheManager,集合spring缓存工厂 -->  
        <!-- <property name="cacheManager" ref="shiroEhcacheManager" /> -->  
        <!-- <property name="sessionManager" ref="sessionManager" /> -->  
    </bean>  
  
    <!-- Shiro生命周期处理器 -->  
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>  
  
</beans>  

ehcache-shiro.xml

[html] view plaincopyprint?
<ehcache updateCheck="false" name="shiroCache">  
  
    <defaultCache  
            maxElementsInMemory="10000"  
            eternal="false"  
            timeToIdleSeconds="120"  
            timeToLiveSeconds="120"  
            overflowToDisk="false"  
            diskPersistent="false"  
            diskExpiryThreadIntervalSeconds="120"  
            />  
</ehcache>  

6、MyBatis 配置

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration  
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
        "http://mybatis.org/dtd/mybatis-3-config.dtd">  
<configuration>  
    <properties>  
        <property name="dialectClass" value="com.eliteams.quick4j.core.feature.orm.dialect.MySql5Dialect"/>  
    </properties>  
  
    <!-- 配置mybatis的缓存，延迟加载等等一系列属性 -->  
    <settings>  
  
        <!-- 全局映射器启用缓存 -->  
        <setting name="cacheEnabled" value="true"/>  
  
        <!-- 查询时，关闭关联对象即时加载以提高性能 -->  
        <setting name="lazyLoadingEnabled" value="true"/>  
  
        <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->  
        <setting name="multipleResultSetsEnabled" value="true"/>  
  
        <!-- 允许使用列标签代替列名 -->  
        <setting name="useColumnLabel" value="true"/>  
  
        <!-- 不允许使用自定义的主键值(比如由程序生成的UUID 32位编码作为键值)，数据表的PK生成策略将被覆盖 -->  
        <setting name="useGeneratedKeys" value="false"/>  
  
        <!-- 给予被嵌套的resultMap以字段-属性的映射支持 FULL,PARTIAL -->  
        <setting name="autoMappingBehavior" value="PARTIAL"/>  
  
        <!-- 对于批量更新操作缓存SQL以提高性能 BATCH,SIMPLE -->  
        <!-- <setting name="defaultExecutorType" value="BATCH" /> -->  
  
        <!-- 数据库超过25000秒仍未响应则超时 -->  
        <!-- <setting name="defaultStatementTimeout" value="25000" /> -->  
  
        <!-- Allows using RowBounds on nested statements -->  
        <setting name="safeRowBoundsEnabled" value="false"/>  
  
        <!-- Enables automatic mapping from classic database column names A_COLUMN to camel case classic Java property names aColumn. -->  
        <setting name="mapUnderscoreToCamelCase" value="true"/>  
  
        <!-- MyBatis uses local cache to prevent circular references and speed up repeated nested queries. By default (SESSION) all queries executed during a session are cached. If localCacheScope=STATEMENT   
            local session will be used just for statement execution, no data will be shared between two different calls to the same SqlSession. -->  
        <setting name="localCacheScope" value="SESSION"/>  
  
        <!-- Specifies the JDBC type for null values when no specific JDBC type was provided for the parameter. Some drivers require specifying the column JDBC type but others work with generic values   
            like NULL, VARCHAR or OTHER. -->  
        <setting name="jdbcTypeForNull" value="OTHER"/>  
  
        <!-- Specifies which Object's methods trigger a lazy load -->  
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>  
  
        <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->  
        <setting name="aggressiveLazyLoading" value="false"/>  
  
    </settings>  
  
    <typeAliases>  
        <package name="com.eliteams.quick4j.web.model"/>  
        <package name="com.eliteams.quick4j.web.enums"/>  
    </typeAliases>  
  
    <plugins>  
        <plugin interceptor="com.eliteams.quick4j.core.feature.orm.mybatis.PaginationResultSetHandlerInterceptor"/>  
        <plugin interceptor="com.eliteams.quick4j.core.feature.orm.mybatis.PaginationStatementHandlerInterceptor"/>  
    </plugins>  
  
</configuration>  

7、Spring MVC 配置

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:aop="http://www.springframework.org/schema/aop"  
       xmlns:context="http://www.springframework.org/schema/context"  
       xmlns:mvc="http://www.springframework.org/schema/mvc"  
       xmlns:tx="http://www.springframework.org/schema/tx"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xmlns:p="http://www.springframework.org/schema/p"  
       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd  
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd   
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd   
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">  
  
    <!-- 扫描controller（controller层注入） -->  
    <context:component-scan base-package="com.eliteams.quick4j.web.controller"/>  
  
    <!-- 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,是spring MVC为@Controllers分发请求所必须的 -->  
    <!-- 指定自己定义的validator -->  
    <mvc:annotation-driven validator="validator"/>  
  
    <!-- 以下 validator ConversionService 在使用 mvc:annotation-driven 会 自动注册 -->  
    <bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">  
        <property name="providerClass" value="org.hibernate.validator.HibernateValidator"/>  
        <!-- 如果不加默认到 使用classpath下的 ValidationMessages.properties -->  
        <property name="validationMessageSource" ref="messageSource"/>  
    </bean>  
  
    <!-- 国际化的消息资源文件（本系统中主要用于显示/错误消息定制） -->  
    <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">  
        <property name="basenames">  
            <list>  
                <!-- 在web环境中一定要定位到classpath 否则默认到当前web应用下找 -->  
                <value>classpath:messages</value>  
                <value>classpath:org/hibernate/validator/ValidationMessages</value>  
            </list>  
        </property>  
        <property name="useCodeAsDefaultMessage" value="false"/>  
        <property name="defaultEncoding" value="UTF-8"/>  
        <property name="cacheSeconds" value="60"/>  
    </bean>  
  
    <mvc:interceptors>  
        <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"/>  
    </mvc:interceptors>  
  
    <bean id="localeResolver" class="org.springframework.web.servlet.i18n.CookieLocaleResolver">  
        <property name="defaultLocale" value="zh_CN"/>  
    </bean>  
  
    <!-- 支持返回json(避免IE在ajax请求时，返回json出现下载 ) -->  
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">  
        <property name="messageConverters">  
            <list>  
                <ref bean="mappingJacksonHttpMessageConverter"/>  
            </list>  
        </property>  
    </bean>  
    <bean id="mappingJacksonHttpMessageConverter"  
          class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">  
        <property name="supportedMediaTypes">  
            <list>  
                <value>text/plain;charset=UTF-8</value>  
                <value>application/json;charset=UTF-8</value>  
            </list>  
        </property>  
    </bean>  
    <!-- 支持返回json -->  
  
    <!-- 对模型视图添加前后缀 -->  
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
          p:prefix="/WEB-INF/views/" p:suffix=".jsp"/>  
  
    <!-- 配置springMVC处理上传文件的信息 -->  
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">  
        <property name="defaultEncoding" value="utf-8"/>  
        <property name="maxUploadSize" value="10485760000"/>  
        <property name="maxInMemorySize" value="40960"/>  
    </bean>  
  
    <!-- 启用shrio授权注解拦截方式 -->  
    <aop:config proxy-target-class="true"></aop:config>  
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">  
        <property name="securityManager" ref="securityManager"/>  
    </bean>  
  
</beans>  

messages.properties ： hibernate-validator 配置文件，国际化资源文件

[plain] view plaincopyprint?
#user  
user.username.null=用户名不能为空  
user.password.null=密码不能为空  

log4j.properties :

[plain] view plaincopyprint?
# DEBUG,INFO,WARN,ERROR,FATAL  
LOG_LEVEL=INFO  
  
log4j.rootLogger=${LOG_LEVEL},CONSOLE,FILE  
  
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender  
log4j.appender.CONSOLE.Encoding=utf-8  
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout  
#log4j.appender.CONSOLE.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss} %C{8}@(%F:%L):%m%n   
log4j.appender.CONSOLE.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH:mm:ss} %C{1}@(%F:%L):%m%n  
  
log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender  
log4j.appender.FILE.File=${catalina.base}/logs/quick4j.log  
log4j.appender.FILE.Encoding=utf-8  
log4j.appender.FILE.DatePattern='.'yyyy-MM-dd  
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout  
#log4j.appender.FILE.layout=org.apache.log4j.HTMLLayout  
log4j.appender.FILE.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH\:mm\:ss} %C{8}@(%F\:%L)\:%m%n   

quick4j.sql

[sql] view plaincopyprint?
/*  
SQLyog 企业版 - MySQL GUI v8.14   
MySQL - 5.5.27 : Database - quick4j  
*********************************************************************  
*/  
  
  
/*!40101 SET NAMES utf8 */;  
  
/*!40101 SET SQL_MODE=''*/;  
  
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;  
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;  
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;  
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;  
CREATE DATABASE /*!32312 IF NOT EXISTS*/`quick4j` /*!40100 DEFAULT CHARACTER SET utf8 */;  
  
USE `quick4j`;  
  
/*Table structure for table `permission` */  
  
DROP TABLE IF EXISTS `permission`;  
  
CREATE TABLE `permission` (  
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '权限id',  
  `permission_name` varchar(32) DEFAULT NULL COMMENT '权限名',  
  `permission_sign` varchar(128) DEFAULT NULL COMMENT '权限标识,程序中判断使用,如"user:create"',  
  `description` varchar(256) DEFAULT NULL COMMENT '权限描述,UI界面显示使用',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='权限表';  
  
/*Data for the table `permission` */  
  
insert  into `permission`(`id`,`permission_name`,`permission_sign`,`description`) values (1,'用户新增','user:create',NULL);  
  
/*Table structure for table `role` */  
  
DROP TABLE IF EXISTS `role`;  
  
CREATE TABLE `role` (  
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '角色id',  
  `role_name` varchar(32) DEFAULT NULL COMMENT '角色名',  
  `role_sign` varchar(128) DEFAULT NULL COMMENT '角色标识,程序中判断使用,如"admin"',  
  `description` varchar(256) DEFAULT NULL COMMENT '角色描述,UI界面显示使用',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='角色表';  
  
/*Data for the table `role` */  
  
insert  into `role`(`id`,`role_name`,`role_sign`,`description`) values (1,'admin','admin','管理员');  
  
/*Table structure for table `role_permission` */  
  
DROP TABLE IF EXISTS `role_permission`;  
  
CREATE TABLE `role_permission` (  
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '表id',  
  `role_id` bigint(20) unsigned DEFAULT NULL COMMENT '角色id',  
  `permission_id` bigint(20) unsigned DEFAULT NULL COMMENT '权限id',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='角色与权限关联表';  
  
/*Data for the table `role_permission` */  
  
insert  into `role_permission`(`id`,`role_id`,`permission_id`) values (1,2,1);  
  
/*Table structure for table `user` */  
  
DROP TABLE IF EXISTS `user`;  
  
CREATE TABLE `user` (  
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户id',  
  `username` varchar(50) DEFAULT NULL COMMENT '用户名',  
  `password` char(64) DEFAULT NULL COMMENT '密码',  
  `state` varchar(32) DEFAULT NULL COMMENT '状态',  
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='用户表';  
  
/*Data for the table `user` */  
  
insert  into `user`(`id`,`username`,`password`,`state`,`create_time`) values (1,'starzou','8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92',NULL,'2014-07-17 12:59:08');  
  
/*Table structure for table `user_role` */  
  
DROP TABLE IF EXISTS `user_role`;  
  
CREATE TABLE `user_role` (  
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '表id',  
  `user_id` bigint(20) unsigned DEFAULT NULL COMMENT '用户id',  
  `role_id` bigint(20) unsigned DEFAULT NULL COMMENT '角色id',  
  PRIMARY KEY (`id`)  
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='用户与角色关联表';  
  
/*Data for the table `user_role` */  
  
insert  into `user_role`(`id`,`user_id`,`role_id`) values (1,1,1);  
  
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;  
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;  
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;  
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;  

封装Spring MVC中的JSON数据

package com.eduoinfo.finances.bank.core.entity;  
  
import java.io.Serializable;  
  
/** 
 * Response JsonResult for RESTful <br> 
 * 封装 返回Json 格式数据 
 *  
 * @author StarZou 
 * @since 2014年5月26日 上午10:51:46 
 **/  
  
public class JsonResult<T> implements Serializable {  
    private static final long serialVersionUID = -4699713095477151086L;  
  
    /** 
     * 数据 
     */  
    private T data;  
    /** 
     * 信息 
     */  
    private String message;  
    /** 
     * 是否成功 
     */  
    private boolean success;  
  
    public Object getData() {  
        return data;  
    }  
  
    public void setData(T data) {  
        this.data = data;  
    }  
  
    public String getMessage() {  
        return message;  
    }  
  
    public void setMessage(String message) {  
        this.message = message;  
    }  
  
    public boolean isSuccess() {  
        return success;  
    }  
  
    public void setSuccess(boolean success) {  
        this.success = success;  
    }  
  
    public JsonResult() {  
        super();  
    }  
  
    public JsonResult(T data, String message, boolean success) {  
        this.data = data;  
        this.message = message;  
        this.success = success;  
    }  
  
    public JsonResult(T data, String message) {  
        this.data = data;  
        this.message = message;  
        this.success = true;  
    }  
  
    public JsonResult(T data) {  
        this.data = data;  
        this.success = true;  
    }  
}  

[java] view plaincopyprint?
/** 
  * 测试 spring mvc 返回 json , 封装 Json 格式数据, 减少 类型转换 
  *  
  * @return 
  */  
 @RequestMapping("/json")  
 @ResponseBody  
 public JsonResult<Object[]> returnJson() {  
     // 实际情况 下 String,可能是一个 自定义的Java 类,比如 User , 通常是在 数据库查询  
     List<String> data = new ArrayList<>();  
     Set<String> data2 = new HashSet<>();  
     Map<String, String> data3 = new HashMap<>();  
  
     int i = 0;  
     while (i < 10) {  
         String value = "data-" + (++i);  
         data.add(value);  
         data2.add(value);  
         data3.put(value, value);  
     }  
  
     // 组装 查询的 结果 , 添加消息 和 是否成功的标识  
     JsonResult<List<String>> jsonResult = new JsonResult<>(data, "This is a message.", true);  
     JsonResult<Set<String>> jsonResult2 = new JsonResult<>(data2, "This is a message.", true);  
     JsonResult<Map<String, String>> jsonResult3 = new JsonResult<>(data3, "This is a message.", true);  
  
     // 复杂一点的 封装  
     Object[] objs = { jsonResult, jsonResult2, jsonResult3 };  
     JsonResult<Object[]> jsonObj = new JsonResult<Object[]>(objs);  
     return jsonObj;  
 }  

applicationContext.xml 文件配置详解

[html] view plaincopyprint?
<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:cache="http://www.springframework.org/schema/cache"  
    xsi:schemaLocation="  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/tx  
    http://www.springframework.org/schema/tx/spring-tx.xsd  
    http://www.springframework.org/schema/jdbc  
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd  
    http://www.springframework.org/schema/cache  
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd  
    http://www.springframework.org/schema/aop  
    http://www.springframework.org/schema/aop/spring-aop.xsd  
    http://www.springframework.org/schema/util  
    http://www.springframework.org/schema/util/spring-util.xsd">  
  
    <!-- 自动扫描web包 ,将带有注解的类 纳入spring容器管理 -->  
    <context:component-scan base-package="com.eduoinfo.finances.bank.web"></context:component-scan>  
  
    <!-- 引入jdbc配置文件 -->  
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="locations">  
            <list>  
                <value>classpath*:jdbc.properties</value>  
            </list>  
        </property>  
    </bean>  
  
    <!-- dataSource 配置 -->  
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
        <!-- 基本属性 url、user、password -->  
        <property name="url" value="${jdbc.url}" />  
        <property name="username" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" />  
  
        <!-- 配置初始化大小、最小、最大 -->  
        <property name="initialSize" value="1" />  
        <property name="minIdle" value="1" />  
        <property name="maxActive" value="20" />  
  
        <!-- 配置获取连接等待超时的时间 -->  
        <property name="maxWait" value="60000" />  
  
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->  
        <property name="timeBetweenEvictionRunsMillis" value="60000" />  
  
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->  
        <property name="minEvictableIdleTimeMillis" value="300000" />  
  
        <property name="validationQuery" value="SELECT 'x'" />  
        <property name="testWhileIdle" value="true" />  
        <property name="testOnBorrow" value="false" />  
        <property name="testOnReturn" value="false" />  
  
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->  
        <property name="poolPreparedStatements" value="false" />  
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />  
  
        <!-- 配置监控统计拦截的filters -->  
        <property name="filters" value="stat" />  
    </bean>  
  
    <!-- mybatis文件配置，扫描所有mapper文件 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" p:dataSource-ref="dataSource" p:configLocation="classpath:mybatis-config.xml" p:mapperLocations="classpath:com/eduoinfo/finances/bank/web/dao/*.xml" />  
  
    <!-- spring与mybatis整合配置，扫描所有dao -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" p:basePackage="com.eduoinfo.finances.bank.web.dao" p:sqlSessionFactoryBeanName="sqlSessionFactory" />  
  
    <!-- 对dataSource 数据源进行事务管理 -->  
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSource" />  
  
    <!-- 配置使Spring采用CGLIB代理 -->  
    <aop:aspectj-autoproxy proxy-target-class="true" />  
  
    <!-- 启用对事务注解的支持 -->  
    <tx:annotation-driven transaction-manager="transactionManager" />  
  
    <!-- Cache配置 -->  
    <cache:annotation-driven cache-manager="cacheManager" />  
    <bean id="ehCacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" p:configLocation="classpath:ehcache.xml" />  
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager" p:cacheManager-ref="ehCacheManagerFactory" />  
  
</beans>  

1、<context:component-scan base-package="com.eduoinfo.finances.bank.web"></context:component-scan> 作用

Spring 容器初始化的时候，会扫描 com.eduoinfo.finances.bank.web下标有 (@Component,@Service,@Controller,@Repository) 注解的类纳入spring容器管理

在类上，使用以下注解，实现bean 的声明

@Component 泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

@Service 用于标注业务层组件

@Controller 用于标注控制层组件（如srping mvc的controller,struts中的action）

@Repository 用于标注数据访问组件，即DAO组件

示例：

@Controller
@RequestMapping(value = "/test")
public class TestController {

}

------------------------------------------------------------------------------------------------------------------

在类的成员变量上,使用以下注解，实现属性的自动装配

@Autowired : 按类的类型进行装配

@Resource (推荐) : 1 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常

3.如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常

4.如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

@Resource注解在字段上，这样就不用写setter方法了，并且这个注解是属于J2EE的，减少了与spring的耦合。

示例：

@Resource
private TestServiceImpl testServiceImpl;

基于HttpClient 多线程爬虫实践

1、首先添加Maven 依赖

[html] view plaincopyprint?
<dependency>  
    <groupId>junit</groupId>  
    <artifactId>junit</artifactId>  
    <version>4.11</version>  
    <scope>test</scope>  
</dependency>  
<dependency>  
    <groupId>org.apache.httpcomponents</groupId>  
    <artifactId>fluent-hc</artifactId>  
    <version>4.3.3</version>  
</dependency>  

2、上 QQUtil工具类：使用junit 运行 mkdir() 方法创建保存的文件夹

[java] view plaincopyprint?
package com.eliteams.index.study.httpclient;  
  
import java.io.File;  
import java.util.Random;  
import org.junit.Test;  
  
/** 
 * QQ 工具类 
 *  
 * @author StarZou 
 * @since 2014年5月26日 下午8:07:59 
 **/  
public class QQUtil {  
    /** 
     * QQ用户头像地址 
     */  
    public static String QQ_LOGO_URL = "http://qlogo4.store.qq.com/qzone/QQNumber/QQNumber/100";  
  
    /** 
     * QQ 信息URl 
     */  
    public static String QQ_INFO_URL = "http://r.cnc.qzone.qq.com/cgi-bin/user/cgi_personal_card?uin=954443045&fupdate=1&g_tk=2082931194&rd=1401115199";  
  
    /** 
     * 头像保存的路径 
     */  
    public static String FILE_PATH = "F:/qlogo/";  
  
    /** 
     * 文件的后缀 
     */  
    public static String FILE_SUFFIX = ".jpg";  
  
    /** 
     * 生成QQ号码的随机器 
     */  
    public static Random qqNumRandom = new Random();  
  
    /** 
     * QQ号码 起始基数 
     */  
    public static int QQ_NUM_CARDINAL = 100000;  
  
    /** 
     * QQ号码 max 基数 
     */  
    public static int QQ_MAX_NUM = 999900000;  
  
    /** 
     * 生成QQ号码 
     *  
     * @return qq 
     */  
    public static String generateQQNum() {  
        return String.valueOf((QQ_NUM_CARDINAL + QQUtil.qqNumRandom.nextInt(QQ_MAX_NUM)));  
    }  
  
    /** 
     * 生成头像URL 
     *  
     * @param qq 
     * @return url 
     */  
    public static String generateLogoUrl(String qq) {  
        return QQ_LOGO_URL.replaceAll("QQNumber", qq);  
    }  
  
    /** 
     * 生成保存在本地的路径 
     *  
     * @param qq 
     * @return path 
     */  
    public static String generatePath(String qq) {  
        return new StringBuffer(FILE_PATH).append(qq).append(FILE_SUFFIX).toString();  
    }  
  
    /** 
     * 创建文件夹 
     */  
    @Test  
    public void mkdir() {  
        File file = new File(FILE_PATH);  
        if (!file.exists()) {  
            file.mkdirs();  
        }  
        System.out.println("创建文件夹:" + FILE_PATH + "成功.");  
    }  
  
    /** 
     * 删除文件夹 
     */  
    @Test  
    public void rmdir() {  
        File file = new File(FILE_PATH);  
        if (file.exists()) {  
            File files[] = file.listFiles();  
            for (int i = 0; i < files.length; i++) {  
                files[i].delete();  
            }  
            file.delete();  
        }  
        System.out.println("删除文件夹:" + FILE_PATH + "成功.");  
    }  
  
}  

3、重量级人物来也，FindBeautyTherad.java

[java] view plaincopyprint?
package com.eliteams.index.study.httpclient;  
  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.ArrayList;  
import java.util.List;  
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.client.ClientProtocolException;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.util.EntityUtils;  
  
/** 
 * 寻找QQ美女的 线程 
 *  
 * @author StarZou 
 * @since 2014年5月26日 下午8:06:32 
 **/  
public class FindBeautyTherad implements Runnable {  
    public static CloseableHttpClient httpClient = HttpClients.createDefault();  
  
    public void run() {  
        while (true) {  
            // 生成QQ号码,头像URL,本地保存路径  
            final String qq = QQUtil.generateQQNum();  
            final String qqLogoUrl = QQUtil.generateLogoUrl(qq);  
            final String path = QQUtil.generatePath(qq);  
  
            HttpGet httpGet = new HttpGet(qqLogoUrl);  
            // 模拟谷歌 爬虫  
            httpGet.setHeader("User-Agent", "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)");  
            try {  
                // 执行请求  
                HttpResponse response = httpClient.execute(httpGet);  
                HttpEntity entity = response.getEntity();  
                // entity不为空,且不是默认的图片,则保存  
                if (entity != null && entity.getContentLength() != 2055) {  
                    File storeFile = new File(path);  
                    FileOutputStream output = new FileOutputStream(storeFile);  
                    InputStream instream = entity.getContent();  
                    byte b[] = new byte[8192];  
                    int j = 0;  
                    while ((j = instream.read(b)) != -1) {  
                        output.write(b, 0, j);  
                    }  
                    instream.close();  
                    output.flush();  
                    output.close();  
                    EntityUtils.consume(entity);  
                    System.out.println(qq + " 下载完成...");  
                }  
            } catch (ClientProtocolException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        // 目标线程  
        FindBeautyTherad target = new FindBeautyTherad();  
  
        // 代理线程  
        List<Thread> proxy = new ArrayList<Thread>();  
        for (int i = 0; i < 10; i++) {  
            proxy.add(new Thread(target, "Thread-" + i));  
        }  
  
        // 启动线程  
        for (Thread thread : proxy) {  
            thread.start();  
        }  
    }  
}  

Hibernate一对一最佳实践

好久没有写东西了，最近几个项目都是在用mybatis 做，还是发现使用 hibernate 更简单高效，

关于 hibernate 的资料，网上很多，但是没有一些总结的很好的资料，

通过一个实例，来讲解hibernate 的，可以帮助我们彻底的搞清 hibernate 的对象关系映射。

首先看我们的 ER 图：涵盖了一对一，一对多，多对多的关系

一对一在 hibernate 中的实现：一个用户user ，拥有一张身份证 id_card ；一张身份证 id_card 属于一个用户user

User.java 及映射文件

[java] view plaincopyprint?
import java.util.Date;  
  
public class User implements java.io.Serializable {  
    private static final long serialVersionUID = 1636556781734875928L;  
    private Long id;  
    private String username;  
    private String password;  
    private String state;  
    private Date createTime;  
  
    private IdCard idCard;  
}  

[html] view plaincopyprint?
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
<hibernate-mapping package="com.eliteams.quick4j.test.study.hibernate.example">  
    <class name="User" table="user">  
        <id name="id" type="java.lang.Long">  
            <column name="id" />  
            <generator class="identity" />  
        </id>  
        <property name="username" type="string">  
            <column name="username" length="50">  
            </column>  
        </property>  
        <property name="password" type="string">  
            <column name="password" length="64">  
            </column>  
        </property>  
        <property name="state" type="string">  
            <column name="state" length="32">  
            </column>  
        </property>  
        <property name="createTime" type="timestamp">  
            <column name="create_time" length="19">  
            </column>  
        </property>  
  
        <one-to-one name="idCard" cascade="all">  
        </one-to-one>  
    </class>  
</hibernate-mapping>  

IdCard.java 及映射文件

[java] view plaincopyprint?
public class IdCard implements java.io.Serializable {  
  
    private static final long serialVersionUID = 4655357806608951570L;  
    private long id;  
    private String cardNo;  
  
    private User user;  
}  

[html] view plaincopyprint?
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
<hibernate-mapping package="com.eliteams.quick4j.test.study.hibernate.example">  
    <class name="IdCard" table="id_card">  
        <id name="id" type="long" column="id">  
            <generator class="foreign">  
                <param name="property">user</param>  
            </generator>  
        </id>  
  
        <property name="cardNo" type="string">  
            <column name="card_no" length="36" />  
        </property>  
  
        <one-to-one name="user"></one-to-one>  
    </class>  
</hibernate-mapping>  

一对一最佳实践：

user 是主表，id_card 是从表；

先有 user 用户，然后才有 id_card 的；

所以我们建表的时候 user 的主键设为自增；在映射 id_card 的主键的时候，标识它是引用 user 表的主键

我们通常在主表中设置 cascade 属性，来级联操作从表，保证数据的正确性，减少错误冗余

以下是删除用户的操作，会级联删除它相对应的身份证，可以看出 hibernate 是先删从表，然后再删除主表

[java] view plaincopyprint?
@Test  
    public void test_delete() {  
        Session session = sessionFactory.getCurrentSession();  
        Transaction transaction = session.beginTransaction();  
        User user = (User) session.get(User.class, 5L);  
  
        session.delete(user);  
        transaction.commit();  
    }  

Hibernate一对多最佳实践

首先看我们的 ER 图：涵盖了一对一，一对多，多对多的关系

一对多在 hibernate 中的实现：一个用户user ，拥有多条 user_log；一条 user_log  只属于一个用户user
User.java 及映射文件
[java] view plaincopyprint?
import java.util.Date;
import java.util.Set;

public class User implements java.io.Serializable {
    private static final long serialVersionUID = 1636556781734875928L;
    private Long id;
    private String username;
    private String password;
    private String state;
    private Date createTime;

    private IdCard idCard;
    private Set<UserLog> userLogs;

    public User() {
    }
}
[html] view plaincopyprint?
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.eliteams.quick4j.test.study.hibernate.example">
    <class name="User" table="user">
        <id name="id" type="java.lang.Long">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="username" type="string">
            <column name="username" length="50">
            </column>
        </property>
        <property name="password" type="string">
            <column name="password" length="64">
            </column>
        </property>
        <property name="state" type="string">
            <column name="state" length="32">
            </column>
        </property>
        <property name="createTime" type="timestamp">
            <column name="create_time" length="19">
            </column>
        </property>

        <one-to-one name="idCard" cascade="all">
        </one-to-one>

        <set name="userLogs" inverse="true">
            <key column="user_id"></key>
            <one-to-many class="UserLog" />
        </set>
    </class>
</hibernate-mapping>

UserLog.java 及映射文件
[java] view plaincopyprint?
import java.util.Date;

public class UserLog implements java.io.Serializable {
    private static final long serialVersionUID = -9195962377534888242L;
    private Long id;
    private Long userId;
    private String type;
    private String description;
    private Date createTime;

    private User user;
}
[html] view plaincopyprint?
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.eliteams.quick4j.test.study.hibernate.example.UserLog" table="user_log" catalog="quick4j">
        <id name="id" type="java.lang.Long">
            <column name="id" />
            <generator class="identity" />
        </id>
        <property name="type" type="string">
            <column name="type" length="32" />
        </property>
        <property name="description" type="string">
            <column name="description" />
        </property>
        <property name="createTime" type="timestamp">
            <column name="create_time" length="19" />
        </property>

        <many-to-one name="user" column="user_id">
        </many-to-one>
    </class>
</hibernate-mapping>

一对多最佳实践：
一个用户user ，拥有多条 user_log；
我们使用
private Set<UserLog> userLogs;
<set name="userLogs" inverse="true">
<key column="user_id"></key>
<one-to-many class="UserLog" />
</set>
来映射，我们通常在多的一端配置 inverse="true" ，表示放弃维护关系（默认值为false，即维护关系），
如果在多的一端不设置 inverse="true"，那么我们在多的一端保存会发生什么呢？
[java] view plaincopyprint?
@Test
    public void test_one2many_add() {
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        User user = (User) session.get(User.class, 10L);

        Set<UserLog> userLogs = user.getUserLogs();
        UserLog userLog1 = new UserLog(LogType.EXECUTE.toString(), null);
        UserLog userLog2 = new UserLog(LogType.EXECUTE.toString(), null);
        userLogs.add(userLog1);
        userLogs.add(userLog2);

        session.save(user);

        transaction.commit();
    }

我们看到 hibernate 先插入 UserLog ，然后又发出sql 更改它的 user_id，
在多的一端设置 inverse="true" ，则不会  去发出sql 更改它的 user_id
=====================================================================
那么我们在一的一端保存会发生什么呢？
[java] view plaincopyprint?
@Test
    public void test_one2many_add2() {
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        User user = (User) session.get(User.class, 10L);

        UserLog userLog1 = new UserLog(LogType.EXECUTE.toString(), null);
        UserLog userLog2 = new UserLog(LogType.EXECUTE.toString(), null);

        userLog1.setUser(user);
        userLog2.setUser(user);

        session.save(userLog1);
        session.save(userLog2);

        transaction.commit();
    }

我们看到只发出 2条 insert 语句新增，因为
userLog1.setUser(user);
<many-to-one name="user" column="user_id"></many-to-one>
userLog 对象中设置了 user 对象，此时是知道 user 对象的id ，而 many-to-one 的映射，
则把user 对象的id ，设置在 userLog 的 user_id 上，所以一次插入就行了。

即一对多最佳实践：
在多的一端设置 inverse="true" 放弃维护关系；
在一的一端维护关系。

细想一下很合理，在 user 中我们可以通过 user.getUserLogs(); 看到这个用户的所有 log；
而我们要为用户添加一条 log 时，保证好  userLog1.setUser(user); 就行了

如果我们删除用户user，要级联删除它的 userlog
则在用户的映射文件中，设置 cascade="delete"，即可
<set name="userLogs" inverse="true" cascade="delete">
<key column="user_id"></key>
<one-to-many class="UserLog" />
</set>

hibernate 先删除 userlog ，再删除 user

Hibernate多对多最佳实践

首先看我们的 ER 图：涵盖了一对一，一对多，多对多的关系

多对多在 hibernate 中的实现：一个用户user ，拥有多个角色 role；一个角色属于多个用户user

其实多对多就是双向的一对多，我们使用一个中间表 user_role 来保存 user ，role 的主键，来确定它们的关联关系，

减少数据的低级冗余，提高可扩展性

User.java 及映射文件

[java] view plaincopyprint?
public class User implements java.io.Serializable {  
    private static final long serialVersionUID = 1636556781734875928L;  
    private Long id;  
    private String username;  
    private String password;  
    private String state;  
    private Date createTime;  
  
    private IdCard idCard;  
    private Set<UserLog> userLogs;  
    private Set<Role> roles;  
}  

[html] view plaincopyprint?
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
<hibernate-mapping package="com.eliteams.quick4j.test.study.hibernate.example">  
    <class name="User" table="user">  
        <id name="id" type="java.lang.Long">  
            <column name="id" />  
            <generator class="identity" />  
        </id>  
        <property name="username" type="string">  
            <column name="username" length="50">  
            </column>  
        </property>  
        <property name="password" type="string">  
            <column name="password" length="64">  
            </column>  
        </property>  
        <property name="state" type="string">  
            <column name="state" length="32">  
            </column>  
        </property>  
        <property name="createTime" type="timestamp">  
            <column name="create_time" length="19">  
            </column>  
        </property>  
  
        <one-to-one name="idCard" cascade="all">  
        </one-to-one>  
  
        <set name="userLogs" inverse="true" cascade="delete">  
            <key column="user_id"></key>  
            <one-to-many class="UserLog" />  
        </set>  
  
        <set name="roles" table="user_role" cascade="save-update">  
            <key column="user_id"></key>  
            <many-to-many column="role_id" class="Role"></many-to-many>  
        </set>  
    </class>  
</hibernate-mapping>  

Role.java 及映射文件

[java] view plaincopyprint?
import java.util.Set;  
  
public class Role implements java.io.Serializable {  
    private static final long serialVersionUID = -5094780060641842069L;  
    private Long id;  
    private String roleName;  
    private String roleSign;  
    private String description;  
    private Set<User> users;  
}  

[html] view plaincopyprint?
<?xml version="1.0"?>  
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
<hibernate-mapping package="com.eliteams.quick4j.test.study.hibernate.example">  
    <class name="Role" table="role" catalog="quick4j">  
        <id name="id" type="java.lang.Long">  
            <column name="id" />  
            <generator class="identity" />  
        </id>  
        <property name="roleName" type="string">  
            <column name="role_name" length="32">  
            </column>  
        </property>  
        <property name="roleSign" type="string">  
            <column name="role_sign" length="128">  
            </column>  
        </property>  
        <property name="description" type="string">  
            <column name="description" length="256">  
            </column>  
        </property>  
  
        <set name="users" table="user_role" inverse="true">  
            <key column="role_id"></key>  
            <many-to-many column="user_id" class="User"></many-to-many>  
        </set>  
    </class>  
</hibernate-mapping>  