作者QQ：1095737364    QQ群：123300273     欢迎加入！

　建立好maven多模块项目后,开始使用ssm传统的框架:http://www.cnblogs.com/yysbolg/p/6898453.html

1.打开总工程下的pom.xml文件:添加如下代码:

  1. <!--全局的所有版本号定义-->
  2.     <properties>
  3.         <!-- 日志管理 -->
  4.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  5.         <logback.version>1.1.7</logback.version>
  6.         <slf4j.version>1.7.21</slf4j.version>
  7.         <janino.version>2.7.8</janino.version>
  8.         <!-- 数据库 -->
  9.         <db.mysql>5.1.30</db.mysql>
  10.         <db.pool.druid>1.0.9</db.pool.druid>
  11.         <!-- 主要依赖库的版本定义 -->
  12.         <spring.version>4.1.3.RELEASE</spring.version>
  13.         <aspectj.version>1.8.4</aspectj.version>
  14.         <mybatis.version>3.2.7</mybatis.version>
  15.         <mybatis-spring.version>1.2.2</mybatis-spring.version>
  16.         <commons-lang3.version>3.3.2</commons-lang3.version>
  17.         <commons-io.version>2.4</commons-io.version>
  18.     </properties>
  19.     <dependencies>
  20.         <!-- 日志文件管理包 -->
  21.         <!--  logback+slf4j -->
  22.         <dependency>
  23.             <groupId>org.slf4j</groupId>
  24.             <artifactId>slf4j-api</artifactId>
  25.             <version>${slf4j.version}</version>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>ch.qos.logback</groupId>
  29.             <artifactId>logback-core</artifactId>
  30.             <version>${logback.version}</version>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>ch.qos.logback</groupId>
  34.             <artifactId>logback-access</artifactId>
  35.             <version>${logback.version}</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>ch.qos.logback</groupId>
  39.             <artifactId>logback-classic</artifactId>
  40.             <version>${logback.version}</version>
  41.         </dependency>
  42.         <!-- 日志文件管理包-提高性能log输出性能 -->
  43.         <!--  janino -->
  44.         <dependency>
  45.             <groupId>org.codehaus.janino</groupId>
  46.             <artifactId>commons-compiler</artifactId>
  47.             <version>${janino.version}</version>
  48.         </dependency>
  49.         <dependency>
  50.             <groupId>org.codehaus.janino</groupId>
  51.             <artifactId>janino</artifactId>
  52.             <version>${janino.version}</version>
  53.         </dependency>
  54.     <!-- spring核心包 -->
  55.     <dependency>
  56.         <groupId>org.springframework</groupId>
  57.         <artifactId>spring-core</artifactId>
  58.         <version>${spring.version}</version>
  59.     </dependency>
  60.     <dependency>
  61.         <groupId>org.springframework</groupId>
  62.         <artifactId>spring-jdbc</artifactId>
  63.         <version>${spring.version}</version>
  64.     </dependency>
  65.     <dependency>
  66.         <groupId>org.springframework</groupId>
  67.         <artifactId>spring-oxm</artifactId>
  68.         <version>${spring.version}</version>
  69.     </dependency>
  70.     <dependency>
  71.         <groupId>org.springframework</groupId>
  72.         <artifactId>spring-tx</artifactId>
  73.         <version>${spring.version}</version>
  74.     </dependency>
  75.     <dependency>
  76.         <groupId>org.springframework</groupId>
  77.         <artifactId>spring-aop</artifactId>
  78.         <version>${spring.version}</version>
  79.     </dependency>
  80.     <dependency>
  81.         <groupId>org.springframework</groupId>
  82.         <artifactId>spring-context-support</artifactId>
  83.         <version>${spring.version}</version>
  84.     </dependency>
  85.     <dependency>
  86.         <groupId>org.springframework</groupId>
  87.         <artifactId>spring-test</artifactId>
  88.         <version>${spring.version}</version>
  89.     </dependency>
  90.     <dependency>
  91.         <groupId>org.aspectj</groupId>
  92.         <artifactId>aspectjweaver</artifactId>
  93.         <version>${aspectj.version}</version>
  94.     </dependency>
  95.         <!--常用工具包-->
  96.         <dependency>
  97.             <groupId>org.apache.commons</groupId>
  98.             <artifactId>commons-lang3</artifactId>
  99.             <version>${commons-lang3.version}</version>
  100.         </dependency>
  101.         <dependency>
  102.             <groupId>commons-io</groupId>
  103.             <artifactId>commons-io</artifactId>
  104.             <version>${commons-io.version}</version>
  105.         </dependency>
  106.         <!--json解析:spring-mvc.xml中配置避免IE执行AJAX时，返回JSON出现下载文件-->
  107.         <dependency>
  108.             <groupId>com.fasterxml.jackson.core</groupId>
  109.             <artifactId>jackson-core</artifactId>
  110.             <version>2.7.4</version>
  111.         </dependency>
  112.         <dependency>
  113.             <groupId>com.fasterxml.jackson.core</groupId>
  114.             <artifactId>jackson-databind</artifactId>
  115.             <version>2.7.4</version>
  116.         </dependency>
  117.     <!-- mybatis核心包 -->
  118.     <dependency>
  119.         <groupId>org.mybatis</groupId>
  120.         <artifactId>mybatis</artifactId>
  121.         <version>${mybatis.version}</version>
  122.     </dependency>
  123.     <!-- mybatis/spring包 -->
  124.     <dependency>
  125.         <groupId>org.mybatis</groupId>
  126.         <artifactId>mybatis-spring</artifactId>
  127.         <version>${mybatis-spring.version}</version>
  128.     </dependency>
  129.     <!-- 导入Mysql数据库链接jar包 -->
  130.     <dependency>
  131.         <groupId>mysql</groupId>
  132.         <artifactId>mysql-connector-java</artifactId>
  133.         <version>${db.mysql}</version>
  134.     </dependency>
  135.         <!--阿里巴巴druid连接池-->
  136.         <dependency>
  137.             <groupId>com.alibaba</groupId>
  138.             <artifactId>druid</artifactId>
  139.             <version>${db.pool.druid}</version>
  140.         </dependency>
  141.     </dependencies>

2.在http的resources文件夹下新建application.properties:

  1. #********Mybatis  分库(这里做测试模拟)**************
  2. jdbc.driver = com.mysql.jdbc.Driver
  3.  
  4. jdbc.master.url = jdbc:mysql://localhost:3306/longebo?useUnicode=true&amp;characterEncoding=UTF-8&amp;generateSimpleParameterMetadata=true
  5. jdbc.master.username = root
  6. jdbc.master.password = 1234
  7.  
  8. jdbc.slave.url = jdbc:mysql://localhost:3306/longebo?useUnicode=true&amp;characterEncoding=UTF-8&amp;generateSimpleParameterMetadata=true
  9. jdbc.slave.username = root
  10. jdbc.slave.password = 1234

3.在http的resources文件夹下新建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" xmlns:p="http://www.springframework.org/schema/p"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.                         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
  8.                         http://www.springframework.org/schema/context
  9.                         http://www.springframework.org/schema/context/spring-context-3.1.xsd
  10.                         http://www.springframework.org/schema/aop
  11.                         http://www.springframework.org/schema/aop/spring-aop.xsd">
  12.  
  13.     <!-- spring管理接口和事物，只扫描 -->
  14.     <context:component-scan base-package="com.longebo.common.*,com.longebo.http.server.*">
  15.         <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>
  16.     </context:component-scan>
  17.     <!-- 引入配置文件 -->
  18.     <bean id="propertyConfigurer"
  19.           class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  20.         <property name="location" value="classpath:application.properties" />
  21.     </bean>
  22.     <aop:aspectj-autoproxy/>
  23.  
  24.     <import resource="spring-datasource-master.xml"/>
  25.     <import resource="spring-datasource-slave.xml"/>
  26. </beans>

4.在http的resources文件夹下新建spring-datasource-master.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" xmlns:p="http://www.springframework.org/schema/p"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xmlns:tx="http://www.springframework.org/schema/tx"
  7.        xmlns:aop="http://www.springframework.org/schema/aop"
  8.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  9.                         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
  10.                         http://www.springframework.org/schema/context
  11.                         http://www.springframework.org/schema/context/spring-context-3.1.xsd
  12.                         http://www.springframework.org/schema/mvc
  13.                         http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
  14.                         http://www.springframework.org/schema/tx
  15.                         http://www.springframework.org/schema/tx/spring-tx.xsd
  16.                         http://www.springframework.org/schema/aop
  17.                         http://www.springframework.org/schema/aop/spring-aop.xsd
  18.                         ">
  19.  
  20.     <!--可视化访问地址 http://localhost:8080/druid-->
  21.     <bean id="dataSourceMaster" class="com.alibaba.druid.pool.DruidDataSource" init-method="init"  destroy-method="close">
  22.         <property name="url" value="${jdbc.master.url}" />
  23.         <property name="username" value="${jdbc.master.username}" />
  24.         <property name="password" value="${jdbc.master.password}" />
  25.         <!-- 配置初始化大小、最小、最大 -->
  26.         <property name="initialSize" value="1" />
  27.         <property name="minIdle" value="2" />
  28.         <property name="maxActive" value="20" />
  29.  
  30.         <!-- 配置获取连接等待超时的时间 -->
  31.         <property name="maxWait" value="60000" />
  32.  
  33.         <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
  34.         <property name="timeBetweenEvictionRunsMillis" value="60000" />
  35.  
  36.         <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
  37.         <property name="minEvictableIdleTimeMillis" value="300000" />
  38.  
  39.         <property name="validationQuery" value="SELECT 'x'" />
  40.         <property name="testWhileIdle" value="true" />
  41.         <property name="testOnBorrow" value="false" />
  42.         <property name="testOnReturn" value="false" />
  43.  
  44.         <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
  45.         <property name="poolPreparedStatements" value="true" />
  46.         <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />
  47.  
  48.         <!-- 配置监控统计拦截的filters -->
  49.         <property name="filters" value="stat" />
  50.     </bean>
  51.  
  52.     <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
  53.     <bean id="sqlSessionFactory1" class="org.mybatis.spring.SqlSessionFactoryBean">
  54.         <property name="dataSource" ref="dataSourceMaster" />
  55.         <!-- 自动扫描mapping.xml文件 -->
  56.         <property name="mapperLocations" value="classpath:mybatis/*/*Mapper.xml"></property>
  57.         <!--自动扫描定义typeAliases类型-->
  58.         <property name="typeAliasesPackage" value="com.longebo.common.*"/>
  59.     </bean>
  60.  
  61.     <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
  62.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  63.         <property name="basePackage" value="com.longebo.common.dao" />
  64.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory1"></property>
  65.     </bean>
  66.  
  67.     <bean id="sqlSessionMaster" class="org.mybatis.spring.SqlSessionTemplate" scope="prototype">
  68.         <constructor-arg index="0" ref="sqlSessionFactory1"/>
  69.     </bean>
  70.  
  71.     <aop:config>
  72.         <aop:pointcut id="appService"
  73.                       expression="execution(* com.longebo.common.service..*Service*.*(..))"/>
  74.         <aop:advisor advice-ref="txAdvice1" pointcut-ref="appService"/>
  75.     </aop:config>
  76.     <tx:advice id="txAdvice1" transaction-manager="transactionManager1">
  77.         <tx:attributes>
  78.             <tx:method name="select*" read-only="true"/>
  79.             <tx:method name="find*" read-only="true"/>
  80.             <tx:method name="get*" read-only="true"/>
  81.             <tx:method name="save*" read-only="false"/>
  82.             <tx:method name="*"/>
  83.         </tx:attributes>
  84.     </tx:advice>
  85.     <!-- 注解式事物 -->
  86.     <tx:annotation-driven transaction-manager="transactionManager1" />
  87.     <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
  88.     <bean id="transactionManager1"
  89.           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  90.         <property name="dataSource" ref="dataSourceMaster" />
  91.     </bean>
  92.  
  93. </beans>

5.在http的resources文件夹下新建spring-datasource-slave.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" xmlns:p="http://www.springframework.org/schema/p"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        xmlns:tx="http://www.springframework.org/schema/tx"
  7.        xmlns:aop="http://www.springframework.org/schema/aop"
  8.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  9.                         http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
  10.                         http://www.springframework.org/schema/context
  11.                         http://www.springframework.org/schema/context/spring-context-3.1.xsd
  12.                         http://www.springframework.org/schema/mvc
  13.                         http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
  14.                         http://www.springframework.org/schema/tx
  15.                         http://www.springframework.org/schema/tx/spring-tx.xsd
  16.                         http://www.springframework.org/schema/aop
  17.                         http://www.springframework.org/schema/aop/spring-aop.xsd
  18.                         ">
  19.  
  20.     <bean id="dataSourceSlave" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
  21.         <property name="url" value="${jdbc.slave.url}" />
  22.         <property name="username" value="${jdbc.slave.username}" />
  23.         <property name="password" value="${jdbc.slave.password}" />
  24.         <!-- 配置初始化大小、最小、最大 -->
  25.         <property name="initialSize" value="1" />
  26.         <property name="minIdle" value="1" />
  27.         <property name="maxActive" value="20" />
  28.  
  29.         <!-- 配置获取连接等待超时的时间 -->
  30.         <property name="maxWait" value="60000" />
  31.  
  32.         <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
  33.         <property name="timeBetweenEvictionRunsMillis" value="60000" />
  34.  
  35.         <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
  36.         <property name="minEvictableIdleTimeMillis" value="300000" />
  37.  
  38.         <property name="validationQuery" value="SELECT 'x'" />
  39.         <property name="testWhileIdle" value="true" />
  40.         <property name="testOnBorrow" value="false" />
  41.         <property name="testOnReturn" value="false" />
  42.  
  43.         <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
  44.         <property name="poolPreparedStatements" value="true" />
  45.         <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />
  46.  
  47.         <!-- 配置监控统计拦截的filters -->
  48.         <property name="filters" value="stat" />
  49.     </bean>
  50.  
  51.     <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
  52.     <bean id="sqlSessionFactory2" class="org.mybatis.spring.SqlSessionFactoryBean">
  53.         <property name="dataSource" ref="dataSourceSlave" />
  54.         <!-- 自动扫描mapping.xml文件 -->
  55.         <property name="mapperLocations" value="classpath:mybatis/*/*Mapper.xml"></property>
  56.         <!--自动扫描定义typeAliases类型-->
  57.         <property name="typeAliasesPackage" value="com.longebo.common.*"/>
  58.     </bean>
  59.  
  60.     <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
  61.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  62.         <property name="basePackage" value="com.longebo.common.dao" />
  63.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory2"></property>
  64.     </bean>
  65.  
  66.     <bean id="sqlSessionSlave" class="org.mybatis.spring.SqlSessionTemplate" scope="prototype">
  67.         <constructor-arg index="0" ref="sqlSessionFactory2"/>
  68.     </bean>
  69.  
  70.     <aop:config>
  71.         <aop:pointcut id="appService"
  72.                       expression="execution(* com.longebo.common.service..*Service*.*(..))"/>
  73.         <aop:advisor advice-ref="txAdvice2" pointcut-ref="appService"/>
  74.     </aop:config>
  75.  
  76.     <tx:advice id="txAdvice2" transaction-manager="transactionManager2">
  77.         <tx:attributes>
  78.             <tx:method name="*" read-only="true"/>
  79.         </tx:attributes>
  80.     </tx:advice>
  81.  
  82.     <!-- 注解式事物 -->
  83.     <tx:annotation-driven transaction-manager="transactionManager2" />
  84.     <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
  85.     <bean id="transactionManager2"
  86.           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  87.         <property name="dataSource" ref="dataSourceSlave" />
  88.     </bean>
  89.  
  90. </beans>

6.打开http模块下的pom.xml文件:添加如下代码:

  1.  <!--spring mvc-->
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-webmvc</artifactId>
  5.             <version>${spring.version}</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework</groupId>
  9.             <artifactId>spring-aop</artifactId>
  10.             <version>${spring.version}</version>
  11.         </dependency>
  12.         <!-- 导入java ee jar基础包 -->
  13.         <dependency>
  14.             <groupId>javax</groupId>
  15.             <artifactId>javaee-api</artifactId>
  16.             <version>7.0</version>
  17.         </dependency>
  18.         <!-- 引入标签库 -->
  19.         <dependency>
  20.             <groupId>javax.servlet</groupId>
  21.             <artifactId>jstl</artifactId>
  22.             <version>1.2</version>
  23.             <scope>runtime</scope>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>taglibs</groupId>
  27.             <artifactId>standard</artifactId>
  28.             <version>1.1.2</version>
  29.         </dependency>
  30.         <!-- 自定义标签库 -->
  31.         <dependency>
  32.             <groupId>javax.servlet.jsp</groupId>
  33.             <artifactId>jsp-api</artifactId>
  34.             <version>2.1</version>
  35.             <scope>provided</scope>
  36.         </dependency>

7.在WEB-INF下新建:spring-mvc.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" xmlns:p="http://www.springframework.org/schema/p"
  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-3.1.xsd
  8.                         http://www.springframework.org/schema/context
  9.                         http://www.springframework.org/schema/context/spring-context-3.1.xsd
  10.                         http://www.springframework.org/schema/mvc
  11.                         http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
  12.     <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 -->
  13.     <context:component-scan base-package="com.longebo.http.*" >
  14.         <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
  15.     </context:component-scan>
  16.     <!--
  17.     <mvc:annotation-driven /> 是一种简写形式，完全可以手动配置替代这种简写形式，简写形式可以让初学都快速应用默认配置方案。
  18.     <mvc:annotation-driven /> 会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,
  19.     是spring MVC为@Controllers分发请求所必须的。 并提供了：数据绑定支持，@NumberFormatannotation支持，@DateTimeFormat支持，
  20.     @Valid支持，读写XML的支持（JAXB），读写JSON的支持（Jackson）。后面，我们处理响应ajax请求时，就使用到了对json的支持。
  21.     后面，对action写JUnit单元测试时，要从spring IOC容器中取DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter
  22.     两个bean，来完成测试，取的时候要知道是<mvc:annotation-driven />这一句注册的这两个bean。
  23.      -->
  24.     <mvc:annotation-driven />
  25.     <!--  避免IE执行AJAX时，返回JSON出现下载文件-->
  26.        <bean id="mappingJacksonHttpMessageConverter"
  27.              class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  28.            <property name="supportedMediaTypes">
  29.                <list>
  30.                    <value>application/json;charset=UTF-8</value>
  31.                    <value>text/html;charset=UTF-8</value>
  32.                </list>
  33.            </property>
  34.        </bean>
  35.        <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->
  36.     <bean
  37.             class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
  38.         <property name="messageConverters">
  39.             <list>
  40.                 <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON转换器 -->
  41.             </list>
  42.         </property>
  43.     </bean>
  44.  
  45.     <!-- 定义跳转的文件的前后缀 ，视图模式配置-->
  46.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  47.         <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
  48.         <property name="prefix" value="/WEB-INF/view/" />
  49.         <property name="suffix" value=".jsp" />
  50.     </bean>
  51.  
  52.     <!-- 静态资源配置 -->
  53.  
  54.    <mvc:resources mapping="/static/**" location="static/"/>
  55.  
  56.     <!-- 拦截器配置 -->
  57.     <mvc:interceptors>
  58.         <mvc:interceptor>
  59.             <mvc:mapping path="/**"/>
  60.             <bean  class="com.longebo.http.interceptor.HttpInterceptor">
  61.                 <!--是否开启longebo头部信息认证-->
  62.                 <property name="islongeboAccess" value="true"/>
  63.                 <property name="allowUrls">
  64.                     <list>
  65.                         <!-- 如果请求中包含以下路径，则不进行拦截 -->
  66.                         <value>/</value>
  67.                         <value>/static</value>
  68.                     </list>
  69.                 </property>
  70.             </bean>
  71.         </mvc:interceptor>
  72.     </mvc:interceptors>
  73. </beans>

8.在web.xml中添加如下代码:

  1.  <!-- Spring和mybatis的配置文件 -->
  2.   <context-param>
  3.     <param-name>contextConfigLocation</param-name>
  4.     <param-value>classpath:applicationContext.xml</param-value>
  5.   </context-param>
  6.  
  7.   <!-- 编码过滤器 -->
  8.   <filter>
  9.     <filter-name>encodingFilter</filter-name>
  10.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  11.     <async-supported>true</async-supported>
  12.     <init-param>
  13.       <param-name>encoding</param-name>
  14.       <param-value>UTF-8</param-value>
  15.     </init-param>
  16.   </filter>
  17.   <filter-mapping>
  18.     <filter-name>encodingFilter</filter-name>
  19.     <url-pattern>/*</url-pattern>
  20.   </filter-mapping>
  21.  
  22.   <!-- 防止Spring内存溢出监听器,放在所有监听的最上面 -->
  23.   <listener>
  24.     <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  25.   </listener>
  26.   <!-- Spring监听器 -->
  27.   <listener>
  28.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  29.   </listener>
  30.   <!-- Spring MVC servlet -->
  31.   <servlet>
  32.     <servlet-name>SpringMVC</servlet-name>
  33.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  34.     <init-param>
  35.       <param-name>contextConfigLocation</param-name>
  36.       <param-value>/WEB-INF/spring-mvc.xml</param-value>
  37.     </init-param>
  38.     <load-on-startup>1</load-on-startup>
  39.     <async-supported>true</async-supported>
  40.   </servlet>
  41.   <servlet>
  42.     <servlet-name>DruidStatView</servlet-name>
  43.     <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
  44.   </servlet>
  45.  
  46.   <servlet-mapping>
  47.     <servlet-name>SpringMVC</servlet-name>
  48.     <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
  49.     <url-pattern>/</url-pattern>
  50.   </servlet-mapping>
  51.   <servlet-mapping>
  52.     <servlet-name>DruidStatView</servlet-name>
  53.     <url-pattern>/druid/*</url-pattern>
  54.   </servlet-mapping>
  55.  
  56.   <welcome-file-list>
  57.     <welcome-file>/index.jsp</welcome-file>
  58.   </welcome-file-list>

9.建立文件夹系统:

10.建立测试用例(1):http->interceptor  新建HttpInterceptor.java

  1. package com.longebo.http.interceptor;
  2.  
  3. import com.mysql.jdbc.StringUtils;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.web.servlet.ModelAndView;
  7. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10.  
  11. public class HttpInterceptor extends HandlerInterceptorAdapter {
  12.     public final static Logger logger= LoggerFactory.getLogger(HttpInterceptor.class);
  13.  
  14.     //是否只能longebo用户访问:此处是的默认值为false,就是所有请求都可访问,如果spring-mvc.xml的过滤器配置参数为true,则此处被修改为true
  15.     private boolean islongeboAccess=false;
  16.     public void setIslongeboAccess(boolean islongeboAccess) {  this.islongeboAccess = islongeboAccess; }
  17.     private String[] allowUrls;
  18.     public void setAllowUrls(String[] allowUrls) {
  19.         this.allowUrls = allowUrls;
  20.     }
  21.     @Override
  22.     public boolean preHandle(HttpServletRequest request,
  23.                              HttpServletResponse response, Object handler) throws Exception {
  24.         response.setCharacterEncoding("UTF-8");
  25.         request.setCharacterEncoding("UTF-8");
  26.         //得到请求头Header中的参数User-Agent
  27.         String userAgent=request.getHeader("User-Agent");
  28.         //得到请求地址的相对路径
  29.         String requestUrl = request.getRequestURI().replace(request.getContextPath(), "");
  30.         //如果请求地址为"/",则不进行任何处理,可能会直接到下一个过滤器,ruturn 可以不要;
  31.         if("/".equals(requestUrl)){
  32.             System.out.println("测试 '/' 访问......");
  33.             return true;
  34.         }
  35.         if(!islongeboAccess){
  36.             //处理longebo用户的访问和非此用户的访问,比如做了一个移动端的APP, 分享后的访问不一定是App里面的请求,此时要做一些处理,ruturn 可以不要;
  37.             return true;
  38.         }
  39.         if(!StringUtils.isNullOrEmpty(userAgent)){
  40.             //对请求头进行处理,ruturn 可以不要;
  41.             return true;
  42.         }
  43.         //如果请求中包含以下路径，则不进行拦截
  44.         if(null != allowUrls && allowUrls.length>=1) {
  45.             for(String url : allowUrls) {
  46.                 if(!"/".equals(url) && requestUrl.contains(url)) {
  47.                     return true;
  48.                 }
  49.             }
  50.         }
  51.         logger.error("非longebo客户端访问",userAgent);
  52.         response.getWriter().write("Not Longebo");
  53.         return false;
  54.     }
  55.     @Override
  56.     public void postHandle(HttpServletRequest request,
  57.                            HttpServletResponse response, Object handler,
  58.                            ModelAndView modelAndView) throws Exception {
  59.     }
  60.     @Override
  61.     public void afterCompletion(HttpServletRequest request,
  62.                                 HttpServletResponse response, Object handler, Exception ex)
  63.             throws Exception {
  64.     }
  65. }

11.建立测试用例(2):http->resources->mybatis->system新建UserMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.longebo.common.dao.UserDao">
  4.  
  5.     <resultMap id="result" type="com.longebo.common.entity.User">
  6.         <id property="userId" column="user_id"/>
  7.         <result property="userName" column="user_name"/>
  8.         <result property="passWord" column="password"/>
  9.     </resultMap>
  10.  
  11.     <insert id="saveUser" parameterType="com.longebo.common.entity.User" useGeneratedKeys="true" keyProperty="userId">
  12.         INSERT  INTO  user (user_name
  13.         <if test="passWord!=null and passWord!=''">
  14.             ,password
  15.         </if>
  16.         )
  17.         VALUES (#{userName}
  18.         <if test="passWord!=null and passWord!=''">
  19.             ,#{passWord}
  20.         </if>
  21.         )
  22.     </insert>
  23.  
  24.     <select id="findUserByUserName" parameterType="java.lang.String" resultMap="result">
  25.         SELECT  * FROM  user WHERE user_name=#{userName}
  26.     </select>
  27.  
  28. </mapper>

12.建立测试用例(3):http->controller新建UserController.java

  1. package com.longebo.http.controller;
  2.  
  3. import com.longebo.common.entity.User;
  4. import com.longebo.common.service.UserSerivce;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestMethod;
  9. import org.springframework.web.bind.annotation.ResponseBody;
  10. import org.springframework.web.servlet.ModelAndView;
  11.  
  12. @Controller
  13. public class UserController {
  14.  
  15.     @Autowired
  16.     private UserSerivce userSerivce;
  17.     /**
  18.      * 显示index.jsp页面
  19.      * @return
  20.      */
  21.     @RequestMapping(value = "/", method = {RequestMethod.POST, RequestMethod.GET})
  22.     public ModelAndView index() {
  23.         return new ModelAndView("index");
  24.     }
  25.  
  26.     /**
  27.      * 登陆
  28.      * @return
  29.      */
  30.     @RequestMapping(value = "/login", method = {RequestMethod.POST})
  31.     @ResponseBody
  32.     public String login(User user) {
  33.        User user1= userSerivce.findUserByUserName(user.getUserName());
  34.         if(user1!=null&&user1.getPassWord().equals(user.getPassWord())){
  35.             return "success!";
  36.         }
  37.         return "fail!";
  38.     }
  39.     /**
  40.      * 注册
  41.      * @return
  42.      */
  43.     @RequestMapping(value = "/register", method = {RequestMethod.POST})
  44.     @ResponseBody
  45.     public String register(User user) {
  46.         try {
  47.           userSerivce.saveUser(user);
  48.             return "success!";
  49.         } catch (Exception e) {
  50.             return "fail!";
  51.         }
  52.     }
  53. }

13.建立测试用例(4):common->service新建UserSerivce.java

  1. package com.longebo.common.service;
  2.  
  3. import com.longebo.common.entity.User;
  4.  
  5. public interface UserSerivce {
  6.     /**
  7.      * 保存用户信息，自动设置保存对象的userid
  8.      * @param user
  9.      * @return
  10.      * @throws Exception
  11.      */
  12.     void saveUser(User user) throws Exception;
  13.     /**
  14.      * 根据用户id查询用户信息
  15.      * @param name
  16.      * @return
  17.      */
  18.     User findUserByUserName(String name);
  19. }

14.建立测试用例(5):common->service->impl新建UserSerivceImpl.java

  1. package com.longebo.common.service.impl;
  2.  
  3. import com.longebo.common.dao.UserDao;
  4. import com.longebo.common.entity.User;
  5. import com.longebo.common.service.UserSerivce;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Transactional;
  9. @Service
  10. public class UserSerivceImpl implements UserSerivce {
  11.     @Autowired
  12.     private UserDao userDao;
  13.  
  14.     @Transactional
  15.     public void saveUser(User user) throws Exception {
  16.         userDao.save("saveUser",user);
  17.     }
  18.     public User findUserByUserName(String name) {
  19.         return userDao.selectOne("findUserByUserName",name);
  20.     }
  21. }

15.建立测试用例(6):common->entity新建User.java

  1. package com.longebo.common.entity;
  2.  
  3. import com.longebo.common.basics.AbstractObject;
  4.  
  5. public class User extends AbstractObject {
  6.  
  7.     /** 用户Id */
  8.     private Integer userId;
  9.     /** 用户昵称 */
  10.     private String userName="";
  11.     /** 密码 */
  12.     private String passWord="";
  13.  
  14.     public Integer getUserId() {
  15.         return userId;
  16.     }
  17.  
  18.     public void setUserId(Integer userId) {
  19.         this.userId = userId;
  20.     }
  21.  
  22.     public String getUserName() {
  23.         return userName;
  24.     }
  25.  
  26.     public void setUserName(String userName) {
  27.         this.userName = userName;
  28.     }
  29.  
  30.     public String getPassWord() {
  31.         return passWord;
  32.     }
  33.  
  34.     public void setPassWord(String passWord) {
  35.         this.passWord = passWord;
  36.     }
  37.  
  38.     @Override
  39.     public String toString() {
  40.         return "User{" +
  41.                 "userId=" + userId +
  42.                 ", userName='" + userName + '\'' +
  43.                 ", passWord='" + passWord + '\'' +
  44.                 '}';
  45.     }
  46. }

16.建立测试用例(7):common->dao新建BasicDao.java

  1. package com.longebo.common.dao;
  2.  
  3. import org.mybatis.spring.SqlSessionTemplate;
  4. import org.springframework.stereotype.Service;
  5.  
  6. import javax.annotation.Resource;
  7. import java.io.Serializable;
  8. import java.util.List;
  9.  
  10. @Service
  11. public abstract class BasicDao<T extends Serializable>{
  12.     protected SqlSessionTemplate writeMapper;
  13.     protected SqlSessionTemplate readMapper;
  14.  
  15.     @Resource(name = "sqlSessionMaster")
  16.     private void setWriteMapper(SqlSessionTemplate sqlSession) {
  17.         this.writeMapper = sqlSession;
  18.     }
  19.     @Resource(name = "sqlSessionSlave")
  20.     private void setReadMapper(SqlSessionTemplate sqlSession) {
  21.         this.readMapper = sqlSession;
  22.     }
  23.  
  24.     public T selectOne(String statement,T t){
  25.        return readMapper.selectOne(statement,t);
  26.     }
  27.  
  28.     public <B,V> V selectOne(String statement,B b){
  29.         return readMapper.selectOne(statement,b);
  30.     }
  31.  
  32.     public List<T> selectList(String statement){
  33.         return readMapper.selectList(statement);
  34.     }
  35.  
  36.     public List<T> selectList(String statement,String t){
  37.         return readMapper.selectList(statement,t);
  38.     }
  39.  
  40.     public <B,V>  List<V> selectList(String statement,B b){
  41.         return readMapper.selectList(statement,b);
  42.     }
  43.  
  44.     public int save(String statement,T t) throws Exception{
  45.         return writeMapper.insert(statement , t);
  46.     }
  47.  
  48.     public <B> int save(String statement,B b) throws Exception{
  49.         return writeMapper.insert(statement , b);
  50.     }
  51.  
  52.     public int update(String statement,T t) throws Exception{
  53.         return writeMapper.update(statement , t);
  54.     }
  55.  
  56.     public <B> int update(String statement,B  b) throws Exception{
  57.         return writeMapper.update(statement , b);
  58.     }
  59.  
  60. }

17.建立测试用例(8):common->dao新建UserDao.java

  1. package com.longebo.common.dao;
  2. import com.longebo.common.entity.User;
  3. import org.springframework.stereotype.Service;
  4. @Service
  5. public class UserDao extends BasicDao<User> {
  6. }

18.建立测试用例(9):common->basics新建AbstractObject.java

  1. package com.longebo.common.basics;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * 抽象类，替代Object成为序列化对象
  7.  */
  8. public abstract class AbstractObject implements Serializable{
  9. }

19.建立测试用例(10):WEB-INF->view新建index.jsp

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>index</title>
  5. </head>
  6. <body>
  7. <h1>login</h1>
  8. <form action="/register" method="post">
  9.     <input type="text" name="userName" value="中国">
  10.     <input type="text" name="passWord" value="123">
  11.     <button type="submit">register</button>
  12. </form>
  13. <form action="/login" method="post">
  14.     <input type="text" name="userName" value="中国">
  15.     <input type="text" name="passWord" value="123">
  16.     <button type="submit">login</button>
  17. </form>
  18. </body>
  19. </html>

20.运行项目

2.配置Spring+SpringMvc+Mybatis(分库or读写分离)--Intellij IDAE 2016.3.5的更多相关文章

  1. 3.配置Spring+SpringMvc+Mybatis(分库or读写分离)--Intellij IDAE 2016.3.5

    作者QQ:1095737364    QQ群:123300273     欢迎加入! 建立好maven多模块项目后,开始使用ssm传统的框架:http://www.cnblogs.com/yysbol ...

  2. Maven配置Spring+SpringMVC+MyBatis(3.2.2)Pom 以及 IntelliJ IDEA 怎样打开依赖视图

    Maven配置Spring+SpringMVC+MyBatis(3.2.2)Pom 配置原则: 利用依赖,将所需的jar包加载到project中. 先依赖主要jar包 Spring + Spring ...

  3. spring集成mybatis实现mysql读写分离

    前言 在网站的用户达到一定规模后,数据库因为负载压力过高而成为网站的瓶颈.幸运的是目前大部分的主流数据库都提供主从热备功能,通过配置两台数据库主从关系,可以将一台数据库的数据更新同步到另一台服务器上. ...

  4. SSM框架的配置Spring+Springmvc +Mybatis

    ssm框架是由spring mvc +spring+mybatis组成 快速阅读 通过spring的配置文件spring.xml,在servlet中指定spring mvc的配置文件spring-mv ...

  5. spring结合mybatis实现数据库读写分离

    随着系统用户访问量的不断增加,数据库的频繁访问将成为我们系统的一大瓶颈之一.由于项目前期用户量不大,我们实现单一的数据库就能完成.但是后期单一的数据库根本无法支撑庞大的项目去访问数据库,那么如何解决这 ...

  6. Spring Boot + MyBatis + MySQL 实现读写分离

    读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行,至于谁来做选择数据库这件事儿,无非两个,要么中间件帮我们做,要么程序自己做. 读写分离有两种实现方式: 第一种是依靠中间件(比如:MyCat ...

  7. 基于Spring+SpringMVC+Mybatis的Web系统搭建

    系统搭建的配置大同小异,本文在前人的基础上做了些许的改动,重写数据库,增加依据权限的动态菜单的实现,也增加了后台返回json格式数据的配置,详细参见完整源码. 主要的后端架构:Spring+Sprin ...

  8. SSM 框架-05-详细整合教程(Eclipse版)(Spring+SpringMVC+MyBatis)

    SSM 框架-05-详细整合教程(Eclipse版)(Spring+SpringMVC+MyBatis) 如果你使用的是 Intellij IDEA,请查看: SSM的配置流程详细的写了出来,方便很少 ...

  9. Spring+springmvc+Mybatis整合案例 xml配置版（myeclipse）详细版

    Spring+springmvc+Mybatis整合案例 Version:xml版(myeclipse) 文档结构图: 从底层开始做起: 01.配置web.xml文件 <?xml version ...

随机推荐

  1. 取消input默认样式

    有时候input在页面中被聚焦后会出现默认的边框样式,可以通过以下方法取消去除 .input:focus{ outline: none;}

  2. php web开发安全之csrf攻击的简单演示和防范（一）

    csrf攻击,即cross site request forgery跨站(域名)请求伪造,这里的forgery就是伪造的意思.网上有很多关于csrf的介绍,比如一位前辈的文章浅谈CSRF攻击方式,参考 ...

  3. python3 selenium 如何处理异常情况

    使用场景: 1.元素只有在某一特定情况下才会出现 2.元素定位不到 使用方法: try: except exceptions.NoSuchElementException: 举例说明: # _._ c ...

  4. 微软Build 2017第二天 .NET Standard 2.0 Preview 的客户端跨平台

    微软公司一年一度的开发者大会,即“Microsoft Build 2017”在总部西雅图正式开幕.按照官方安排,本次大会将持续 3 天,主题围绕微软公司各项最新技术成果的展示和研讨,包括与微软相关的产 ...

  5. 响应式web-媒体查询

    响应式web-媒体查询 媒体查询是一个将很多响应式概念和工具连接在一起的粘合剂.这些查询语句都是简单但是功能很强大的,它们允许我们检测设备属性,定义规则,并根据规则等的不同加载不同的 CSS 属性.例 ...

  6. windows上安装jdk

    1.下载jdk安装包 jdk官网   http://www.oracle.com/technetwork/java/javase/downloads/index.html 2.安装jdk 傻瓜式下一步 ...

  7. Fiddler插件 --- 解密Elong Mapi请求参数及响应内容

    当前问题: 在我们日常的Web/App测试过程中, Fiddler是一大辅助利器:在我们团队,也经常使用Fiddler进行App抓包测试. 艺龙 App使用的REST(内部称为Mapi)接口,在使用过 ...

  8. c++ 自动应用类型转换

    c++中,在赋值时如果类型不匹配,就会应用到:类型转换.类型转换又分为隐式转换(implicit conversion) 和 显式强制类型转换(emplcit conversion).在这我围绕着类的 ...

  9. Tomcat 部署项目的三种方法

    1.下载 Tomcat 服务器 ①.官网下载地址:http://tomcat.apache.org/ ②.tomcat 8.0 64位百度云下载地址:http://pan.baidu.com/s/1s ...

  10. JSP中include指令和include动作区别

    首先 <%@ include file=” ”%>:为指令元素 <jsp:include page=” ” flush=”true”/>:为 动作元素 先说指令元素: incl ...