Spring+SpringMVC+SpingDataJPA（基于Hibernate）框架搭建

本文会使用IDEA工具来搭建Spring+SpirngMVC+SpringDataJPA企业常用框架

项目的下载地址是：http://download.csdn.net/download/hongtao_scau/9964916

1 基本知识的介绍

1.1 Spring

Spring 是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

1.2 Spring MVC

 Spring MVC 属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

1.3 Spring Data JPA

Spring JPA通过为用户统一创建和销毁EntityManager，进行事务管理，简化JPA的配置等使用户的开发更加简便。Spring Data JPA是在Spring JPA的基础上，对持久层做了简化。用户只需声明持久层的接口，不需要实现该接口。Spring Data JPA内部会根据不同的策略、通过不同的方法创建Query操作数据库。

1.4 工具介绍

项目用的IDE工具是IDEA 2017 Ultimate，为什么选择IDEA，人性化的开发工具就不介绍那么多了，破解方式网上已经说得够多了。项目构建是用Maven。数据库连接池是用alibaba的druid。服务器使用tomcat，数据库用的是mysql。

2项目的构建

首先，new 一个project，选择Maven项目，然后勾选create from archetype，选择构建webapp项目

之后选择next，填写GropId和ArtifactId，GroupID是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。ArtifactID就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称。

接下来是选择maven工具，笔者用的是自己的maven工具，可以自行安装，也可以使用默认配置的maven。

点击next，配置项目名和路径。然后finish。 等待其加载完。加载完如下图这就完成了创建。

3 项目的配置

3.1 配置pom文件导入依赖jar

pom.xml文件配置如下图：

<?xml version="1.0" encoding="UTF-8"?>
<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>
  <packaging>war</packaging>
  <name>test</name>
  <groupId>com.gosuncn</groupId>
  <artifactId>base</artifactId>
  <version>1.0-SNAPSHOT</version>
  <build>
    <finalName>test</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.6</source>
          <target>1.6</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <!-- spring版本号 -->
    <spring.version>4.2.5.RELEASE</spring.version>

    <!-- mysql驱动版本号 -->
    <mysql-driver.version>5.1.29</mysql-driver.version>

    <!-- log4j日志包版本号 -->
    <slf4j.version>1.7.18</slf4j.version>
    <log4j.version>1.2.17</log4j.version>

    <version-hibernate.validator>5.0.1.Final</version-hibernate.validator>
    <version-hibernate.jpa>1.0.1.Final</version-hibernate.jpa>
    <version-hibernate>4.2.6.Final</version-hibernate>
  </properties>

  <dependencies>
    <!--添加 依赖-->
    <!-- 添加jstl依赖 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- 添加junit4依赖 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <!-- 指定范围，在测试时才会加载 -->
      <scope>test</scope>
    </dependency>

    <!-- 添加spring核心依赖 -->
    <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-context</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-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--hibernate的包-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>${version-hibernate}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>${version-hibernate}</version>
      <exclusions>
        <exclusion>
          <artifactId>cglib</artifactId>
          <groupId>cglib</groupId>
        </exclusion>
        <exclusion>
          <artifactId>dom4j</artifactId>
          <groupId>dom4j</groupId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>${version-hibernate.validator}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate.javax.persistence</groupId>
      <artifactId>hibernate-jpa-2.0-api</artifactId>
      <version>${version-hibernate.jpa}</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>${version-hibernate}</version>
    </dependency>

    <!-- Spring data jpa -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>1.6.2.RELEASE</version>
    </dependency>
    <!-- 添加mysql驱动依赖 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-driver.version}</version>
    </dependency>

    <!-- 添加数据库连接池依赖 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>

    <!-- 添加日志相关jar包 -->
    <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>

    <!-- 映入JSON -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.8.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.0</version>
    </dependency>
    <!--解决tomcat部署跨域问题  -->
    <dependency>
      <groupId>com.thetransactioncompany</groupId>
      <artifactId>cors-filter</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>com.thetransactioncompany</groupId>
      <artifactId>java-property-utils</artifactId>
      <version>1.9.1</version>
    </dependency>

    <!-- 引入alibaba的druid-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.0.14</version>
    </dependency>
  </dependencies>

</project>

3.2 spring的配置

在resources文件夹下新建以下几个文件夹。application.properties是配置文件，里面是属性值，定义的是一些参数applicationConText.xml文件是Spring的配置文件。log4j是日志文件的配置。spring—web.xml是springMVC的配置文件。

 

3.2.1 application.properties配置文件

jdbc.driverClasss=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/dna?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useOldAliasMetadataBehavior=true
jdbc.username=root
jdbc.password=root

#定义初始连接数
jdbc.initialSize=0
#定义最大连接数
jdbc.maxActive=20
#定义最大空闲
jdbc.maxIdle=20
#定义最小空闲
jdbc.minIdle=1
#定义最长等待时间
jdbc.maxWait=60000

3.2.2 login4j.properties

log4j.rootLogger=INFO,Console,File

#控制台日志
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n

#普通文件日志
log4j.appender.File=org.apache.log4j.RollingFileAppender
log4j.appender.File.File=logs/ssm.log
log4j.appender.File.MaxFileSize=10MB
#输出日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold=ALL
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%p][%t][%d{yyyy-MM-dd HH\:mm\:ss}][%C] - %m%n

3.2.3 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd

                        http://www.springframework.org/schema/data/jpa
                        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
                        http://www.springframework.org/schema/tx
                        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 启动组件扫描，排除@Controller组件，该组件由SpringMVC配置文件扫描 -->
    <context:component-scan base-package="base.*">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
    <context:property-placeholder location="classpath:application.properties"></context:property-placeholder>

    <!-- 配置数据源 -->
    <!--<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"-->
          <!--destroy-method="close">-->
        <!--<property name="driverClassName" value="${driverClasss}"/>-->
        <!--<property name="url" value="${jdbcUrl}"/>-->
        <!--<property name="username" value="root"/>-->
        <!--<property name="password" value="root"/>-->
        <!--<!– 初始化连接大小 –>-->
        <!--<property name="initialSize" value="${initialSize}"></property>-->
        <!--<!– 连接池最大数量 –>-->
        <!--<property name="maxActive" value="${maxActive}"></property>-->
        <!--<!– 连接池最大空闲 –>-->
        <!--<property name="maxIdle" value="${maxIdle}"></property>-->
        <!--<!– 连接池最小空闲 –>-->
        <!--<property name="minIdle" value="${minIdle}"></property>-->
        <!--<!– 获取连接最大等待时间 –>-->
        <!--<property name="maxWait" value="${maxWait}"></property>-->
    <!--</bean>-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--druid的基础属性-->
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driverClasss}"/>

        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="1" />
        <property name="minIdle" value="1" />
        <property name="maxActive" value="10" />

        <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" />
        <property name="poolPreparedStatements" value="false" />
        <property name="maxPoolPreparedStatementPerConnectionSize"
                  value="20" />

    </bean>

    <!-- JPA实体管理工厂的配置 -->
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
        <property name="packagesToScan" value="base.bean" /><!--待扫描的实体类包，不再需要persistence.xml了 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

    <!--指定实现JPA的适配器 -->
    <bean id="hibernateJpaVendorAdapter"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
    </bean>

    <!-- Jpa 事务配置 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- Spring Data Jpa 配置 Spring -->
    <!-- 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为
        Spring Bean -->
    <!-- base-package 扫描的包 -->
    <!-- repository-impl-postfix 仓库自定义实现类的后缀。自动扫描该名称带有该后缀的类，并添加到接口的实现 -->
    <!-- factory-class 仓库接口的实现工厂 -->
    <jpa:repositories base-package="base.dao"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager">
    </jpa:repositories>


</beans>

3.2.4 spring-web.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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-4.3.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
       ">

    <mvc:annotation-driven />
    <!-- 配置spring不拦截静态资源-->
    <mvc:resources location="static/image" mapping="/image/**"/>
    <mvc:resources location="static/css" mapping="/css/**"/>
    <mvc:resources location="static/js" mapping="/js/**"/>
    <!-- 自动扫描  @Controller-->
    <context:component-scan base-package="base.controller"/>

    <!-- 视图解析器配置 -->
    <!-- 定义跳转的文件的前后缀 ，视图模式配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/" />
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

3.2.5 web.xml文件的配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
		  http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

  <display-name>test</display-name>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

  <context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
  </context-param>
  <!-- 编码过滤器 -->
  <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>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- spring监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 防止spring内存溢出监听器，比如quartz -->
  <listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
  </listener>

  <!-- spring mvc servlet-->
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-web.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 此处也可以配置成 *.do 形式 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <session-config>
    <session-timeout>20</session-timeout>
  </session-config>

  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>
</web-app> 

到此配置完成，可以进行代码编写

3.3 测试

3.3.1数据库

建立dna库，然后建表user，插入几条记录

/*
Navicat MySQL Data Transfer

Source Server         : localhost_3306
Source Server Version : 50548
Source Host           : localhost:3306
Source Database       : dna

Target Server Type    : MYSQL
Target Server Version : 50548
File Encoding         : 65001

Date: 2017-09-05 11:50:57
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `password` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2017 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('2015', '小李', '456');
INSERT INTO `user` VALUES ('2016', '大牛', '123');

3.3.2后台

1、创建以下目录：在main下创建java包，在依次创建以下包

2、把java包设置为source包

3、创建User的bean类

package base.bean;

import javax.persistence.*;

/**
 * Created by Administrator on 2017/9/4 0004.
 */
@Entity
@Table(name="user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String password;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
}
}

4、创建UserDao类

package base.dao;

import base.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created by Administrator on 2017/9/4 0004.
 */
@Repository
public interface UserDAO extends JpaRepository<User,Integer>{

}

5、创建Base类的controller类

笔者比较懒，省去写service类，在实际开发中，service是提供一系列服务。

package base.controller;

import base.bean.User;
import base.dao.UserDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

/**
 * Created by Administrator on 2017/9/4 0004.
 */
@Controller
@RequestMapping("/test")
public class base {
    @Autowired
    UserDAO userDAO;

    @RequestMapping("/index")
    public ModelAndView test(){
        ModelAndView modelAndView =new ModelAndView("index");
        modelAndView.addObject(userDAO.findOne(2015));
        return modelAndView;
    }

    @RequestMapping("/getdata")
    @ResponseBody
    public User getdata(){
        return userDAO.findOne(2015);
    }

}

3.3.3前台

1、在Web-INF目录下建立以下目录和文件

2、view下的index.jsp

<%--
  Created by IntelliJ IDEA.
  User: Administrator
  Date: 2017/9/4 0004
  Time: 14:26
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
23${user.name}
</body>
</html>

3.3.4 服务器tomcat配置：

1、添加tomcat服务器

2、配置服务器，http://locahots:8080/base是项目的访问路径

3、添加war包，选择war exploded的选项，此处笔者已经配好base：war explode，注意填写application context路径

4、tomcat部署，出现Artifact base:war exploded: Deploy took 10,853 milliseconds，才是不是成功。笔者当前用的是debug模式

3.3.5 浏览器访问

访问 http://localhost:8080/base/test/index

访问http://localhost:8080/base/test/getdata

4 笔者踩过的坑

4.1 aplication.properties属性文件

注意属性对象的命名不要过于简单，会造成与环境变量冲突，然后读不出文件里的属性， 错误例子：uername和password。命名过于简单，导致最后连接数据库失败。

4.2 跨域问题

这个问题关乎前台页面，笔者也是搞了挺久，这里不详细展开，以下是增加在xml中的配置

	<!-- 增加跨域的支持 start -->
	<filter>
		<filter-name>corsFilter</filter-name>
		<filter-class>base.filter.SimpleCORSFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>corsFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

自己写的支持跨域的拦截器

package base.filter;

/**
 * Created by Administrator on 2017/4/30 0030.
 */
import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;

public class SimpleCORSFilter implements Filter{

    @Override
    public void destroy() {

    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse res,
                         FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "Origin, No-Cache, X-Requested-With, If-Modified-Since, Pragma, Last-Modified, Cache-Control, Expires,Content-Type, X-E4M-With");
        chain.doFilter(req, res);

    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {

    }

}

在新的sping中已经支持注解支持跨域， @CrossOrigin；还有一种方法就是配置springMVC拦击器。

4.3 静态资源问题

<!-- 配置spring不拦截静态资源-->

<mvc:resources location="static/image" mapping="/image/**"/>

<mvc:resources location="static/css" mapping="/css/**"/>

<mvc:resources location="static/js" mapping="/js/**"/>

此处在spring-web文件中，使静态文件不被拦截。第二种方法是写在web.xml文件中，配置拦截这些静态资源的访问，但要写在springMVC的DispatcherServlet拦截器之前，才能保证不被拦截。

4.4 spring data jpa的配置

这段代码笔者倒腾了好久，有卡到其他人是用一个 persistence.xml，放在meta-inf目录下，也差不多，只是把一些hibernate的配置写到外边

    <!-- JPA实体管理工厂的配置 -->
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
        <property name="packagesToScan" value="base.bean" /><!--待扫描的实体类包，不再需要persistence.xml了 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

    <!--指定实现JPA的适配器 -->
    <bean id="hibernateJpaVendorAdapter"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
    </bean>

    <!-- Jpa 事务配置 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- Spring Data Jpa 配置 Spring -->
    <!-- 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为
        Spring Bean -->
    <!-- base-package 扫描的包 -->
    <!-- repository-impl-postfix 仓库自定义实现类的后缀。自动扫描该名称带有该后缀的类，并添加到接口的实现 -->
    <!-- factory-class 仓库接口的实现工厂 -->
    <jpa:repositories base-package="base.dao"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager">
    </jpa:repositories>

4.5 log4j配置

log4j的配置很简单，但必须配，原因是：这样才能在控制台看到一个完整的错误输出。

5 标题不知道写什么了

本文的目的是教大家一步步配置一个项目的基础框架。下一篇博文，笔者会为大家介绍然后用springBoot+mybatis快速搭建一个个人博客。