Spring Boot + Jpa(Hibernate) 架構基本配置

一、maven的pom文件

<?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/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.zsx</groupId>
        <artifactId>demo</artifactId>
        <packaging>war</packaging>
        <version>0.0.1</version>
        <name>zsx Maven Webapp</name>
        <url>http://maven.apache.org</url>

        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <jdk.version>1.7</jdk.version>
            <tomcat.version>7.0.69</tomcat.version>
        </properties>

        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.0.RELEASE</version>
        </parent>

        <dependencies>

            <!-- 添加對jsp視圖解析的支持 -->
            <dependency>
                <groupId>org.apache.tomcat.embed</groupId>
                <artifactId>tomcat-embed-jasper</artifactId>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
            </dependency>


            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>


            <!-- 下面兩個引入為了操作數據庫 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>



            <dependency> 
                <groupId>org.springframework.boot</groupId> 
                <artifactId>spring-boot-starter-tomcat</artifactId> 
                <scope>provided</scope> 
            </dependency>

            <!-- 只需引入spring-boot-devtools 即可實現熱部署 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>

            <!-- Json包 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.16</version>
            </dependency>

            <!-- 為了監控數據庫 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.25</version>
            </dependency>


            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi</artifactId>
                <version>3.14</version>
            </dependency>

            <!-- Junit 單元測試 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>

            <dependency> 
                <groupId>io.springfox</groupId> 
                <artifactId>springfox-swagger2</artifactId> 
                <version>2.6.0</version> 
            </dependency> 
            <dependency> 
                <groupId>io.springfox</groupId> 
                <artifactId>springfox-swagger-ui</artifactId> 
                <version>2.6.0</version> 
            </dependency>

        </dependencies>
        <build>
            <finalName>/</finalName>

            <plugins>

                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <dependencies>
                        <!-- 熱部署 -->
                        <dependency>
                            <groupId>org.springframework</groupId>
                            <artifactId>springloaded</artifactId>
                            <version>1.2.6.RELEASE</version>
                        </dependency>
                    </dependencies>
                </plugin>

            </plugins>

        </build>

        <repositories>
            <repository>
                <id>ali</id>
                <name>ali Repository</name>
                <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    </project>

二、項目架構

想想還是介紹一下項目的目錄結構，這樣方便梳理整體的架構配置

src
├─main
    │  ├─java
    │  │  └─com
    │  │      └─zsx
    │  │          │  Application.java
    │  │          │  SpringBootStartApplication.java
    │  │          │  
    │  │          ├─common
    │  │          │  ├─config
    │  │          │  │      DruidDBConfig.java
    │  │          │  │      MultipartConfig.java
    │  │          │  │      
    │  │          │  ├─filter
    │  │          │  │      DruidStatFilter.java
    │  │          │  │      
    │  │          │  ├─interceptors
    │  │          │  │      AuthInterceptor.java
    │  │          │  │      WebAppConfigurer.java
    │  │          │  │      
    │  │          │  ├─servlet
    │  │          │  │      DruidStatViewServlet.java
    │  │          │  │      
    │  │          │  └─swagger
    │  │          │          Swagger2.java
    │  │          │          
    │  │          ├─controller
    │  │          │  │  LoginController.java
    │  │          │  │  TestController.java
    │  │          │  │  UserController.java
    │  │          │          
    │  │          ├─dao
    │  │          │  │  TUserDao.java
    │  │          │  │  
    │  │          │  └─impl
    │  │          ├─entity
    │  │          │  │  BaseEntity.java
    │  │          │          
    │  │          ├─model
    │  │          │  │  Tree.java
    │  │          │          
    │  │          ├─service
    │  │          │  │  UserService.java
    │  │          │  │  
    │  │          │  └─impl
    │  │          │          UserServiceImpl.java
    │  │          │          
    │  │          └─util
    │  │                  GeneratePageable.java
    │  │                  
    │  ├─resources
    │  │  │  application.properties
    │  │  │  logback-test.xml
    │  │  │  
    │  │  └─static
    │  │      ├─css 
    │  │      ├─img
    │  │      └─js
    │  │                  
    │  └─webapp
    │      │  index.jsp
    │      │  
    │      └─WEB-INF
    │          │  web.xml
    │          │  
    │          └─view
    │              │  login.jsp
    │              │      
    │              ├─error
    │              │      500.jsp   
    │              ├─jsp
    │                     main.jsp
    │                      
    └─test
        └─java
                UtilTest.java

標准的maven項目結構，其中java下是dao、service、controller ，還有實體類映射entity，其他配置config

三、resources下的應用配置文件application.properties

    #server.port=9090


    # 數據庫訪問配置
    # 主數據源，默認的
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.url=jdbc:mysql://localhost:3306/test
    spring.datasource.username= root
    spring.datasource.password= root
    spring.datasource.driverClassName = com.mysql.jdbc.Driver


    # 下面為連接池的補充設置，應用到上面所有數據源中
    # 初始化大小，最小，最大
    spring.datasource.initialSize=5
    spring.datasource.minIdle=5
    spring.datasource.maxActive=20
    # 配置獲取連接等待超時的時間
    spring.datasource.maxWait=60000
    # 配置間隔多久才進行一次檢測，檢測需要關閉的空閑連接，單位是毫秒 
    spring.datasource.timeBetweenEvictionRunsMillis=60000
    # 配置一個連接在池中最小生存的時間，單位是毫秒 
    spring.datasource.minEvictableIdleTimeMillis=300000
    spring.datasource.validationQuery=SELECT 1 FROM DUAL
    spring.datasource.testWhileIdle=true
    spring.datasource.testOnBorrow=false
    spring.datasource.testOnReturn=false
    # 打開PSCache，並且指定每個連接上PSCache的大小 
    spring.datasource.poolPreparedStatements=true
    spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
    # 配置監控統計攔截的filters，去掉后監控界面sql無法統計，'wall'用於防火牆 
    spring.datasource.filters=stat,wall,log4j
    # 通過connectProperties屬性來打開mergeSql功能；慢SQL記錄
    spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合並多個DruidDataSource的監控數據
    spring.datasource.useGlobalDataSourceStat=true


    #JPA Configuration:  
    spring.jpa.database=MYSQL
    # Show or not log for each sql query
    spring.jpa.show-sql=false
    spring.jpa.generate-ddl=true  
    # Hibernate ddl auto (create, create-drop, update)
    spring.jpa.hibernate.ddl-auto=create  
    #spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect  
    spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy  
    #spring.jpa.database=org.hibernate.dialect.MySQL5InnoDBDialect 
    spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect


    spring.mvc.view.prefix=/WEB-INF/view/
    spring.mvc.view.suffix=.jsp
    #spring.resources.static-locations=classpath:/resources/,classpath:/static/

四、啟動應用主類文件 Application.java

package com.zsx;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan // 掃描使用注解方式的servlet
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

• 若需要部署到外部的tomcat容器中，則添加下面類即可。

  package com.zsx;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.builder.SpringApplicationBuilder;
  import org.springframework.boot.context.web.SpringBootServletInitializer;
  /**
   * 修改啟動類，繼承 SpringBootServletInitializer 並重寫 configure 方法
   * @author ZSX
   *
   */
  public class SpringBootStartApplication extends SpringBootServletInitializer {
  
      private static final Logger logger = LoggerFactory.getLogger(SpringBootStartApplication.class);
  
      @Override
      protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
          return builder.sources(Application.class);
      }
  
  }
  

五、數據庫連接池Druid的配置

    package com.zsx.common.config;

    import java.sql.SQLException;

    import javax.sql.DataSource;

    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;

    import com.alibaba.druid.pool.DruidDataSource;

    /**
     * DruidDBConfig類被@Configuration標注，用作配置信息； 
     * DataSource對象被@Bean聲明，為Spring容器所管理， 
     * @Primary表示這里定義的DataSource將覆蓋其他來源的DataSource。
     * @author ZSX
     *jdbc.url=${jdbc.url} 
     *最新的支持方式如下: 
     *jdbc.url=@jdbc.url@  
     */
    @Configuration
    public class DruidDBConfig {
    //  private Logger logger = LoggerFactory.getLogger(DruidDBConfig.class);

        @Value("${spring.datasource.url}")
        private String dbUrl;

        @Value("${spring.datasource.username}")
        private String username;

        @Value("${spring.datasource.password}")
        private String password;

        @Value("${spring.datasource.driverClassName}")
        private String driverClassName;

        @Value("${spring.datasource.initialSize}")
        private int initialSize;

        @Value("${spring.datasource.minIdle}")
        private int minIdle;

        @Value("${spring.datasource.maxActive}")
        private int maxActive;

        @Value("${spring.datasource.maxWait}")
        private int maxWait;

        @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
        private int timeBetweenEvictionRunsMillis;

        @Value("${spring.datasource.minEvictableIdleTimeMillis}")
        private int minEvictableIdleTimeMillis;

        @Value("${spring.datasource.validationQuery}")
        private String validationQuery;

        @Value("${spring.datasource.testWhileIdle}")
        private boolean testWhileIdle;

        @Value("${spring.datasource.testOnBorrow}")
        private boolean testOnBorrow;

        @Value("${spring.datasource.testOnReturn}")
        private boolean testOnReturn;

        @Value("${spring.datasource.poolPreparedStatements}")
        private boolean poolPreparedStatements;

        @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
        private int maxPoolPreparedStatementPerConnectionSize;

        @Value("${spring.datasource.filters}")
        private String filters;

        @Value("{spring.datasource.connectionProperties}")
        private String connectionProperties;

        @Bean // 聲明其為Bean實例
        @Primary // 在同樣的DataSource中，首先使用被標注的DataSource
        public DataSource dataSource() {
            DruidDataSource datasource = new DruidDataSource();

            datasource.setUrl(this.dbUrl);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);

            // configuration
            datasource.setInitialSize(initialSize);
            datasource.setMinIdle(minIdle);
            datasource.setMaxActive(maxActive);
            datasource.setMaxWait(maxWait);
            datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            datasource.setValidationQuery(validationQuery);
            datasource.setTestWhileIdle(testWhileIdle);
            datasource.setTestOnBorrow(testOnBorrow);
            datasource.setTestOnReturn(testOnReturn);
            datasource.setPoolPreparedStatements(poolPreparedStatements);
            datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
            try {
                datasource.setFilters(filters);
            } catch (SQLException e) {

            }
            datasource.setConnectionProperties(connectionProperties);

            return datasource;
        }
    }

• springboot里默認使用tomcat的上傳文件大小限制，即1MB，
  修改用下面的配置類：

  import javax.servlet.MultipartConfigElement;
  
  import org.springframework.boot.web.servlet.MultipartConfigFactory;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class MultipartConfig {
  
      @Bean
      public MultipartConfigElement multipartConfigElement(){
          MultipartConfigFactory factory = new MultipartConfigFactory();
          factory.setMaxFileSize("10MB");
          factory.setMaxRequestSize("10MB");
          return factory.createMultipartConfig();
      }
  
  }
  

六、開啟Druid的數據庫監控配置

• 1、配置Filter

  import javax.servlet.annotation.WebFilter;
  import javax.servlet.annotation.WebInitParam;
  
  import com.alibaba.druid.support.http.WebStatFilter;
  
  /**
   * 配置druid監控統計功能
   * 配置Filter
   * @author ZSX
   *
   */
  
  @WebFilter(filterName = "druidWebStatFilter", urlPatterns = "/*",
      initParams = {
              @WebInitParam(name="exclusions",value="*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")// 忽略資源
      }
  )
  
  public class DruidStatFilter extends WebStatFilter {
  
  }
  

• 2、 配置web訪問的servlet

  import javax.servlet.annotation.WebInitParam;
  import javax.servlet.annotation.WebServlet;
  
  import com.alibaba.druid.support.http.StatViewServlet;
  
  
  /**
   * 配置druid監控統計功能
   * 在SpringBoot項目中基於注解的配置，如果是web.xml配置，按規則配置即可
   * @author ZSX
   *
   */
  
  @WebServlet(urlPatterns = "/druid/*",
      initParams = {
  //          @WebInitParam(name = "allow", value = "192.168.16.110,127.0.0.1"), // IP白名單 (沒有配置或者為空，則允許所有訪問)
  //          @WebInitParam(name="deny",value="192.168.16.111"), // IP黑名單 (存在共同時，deny優先於allow)
              @WebInitParam(name="loginUsername",value="druid"),// 用戶名
              @WebInitParam(name="loginPassword",value="druid"),// 密碼
              @WebInitParam(name="resetEnable",value="false")// 禁用HTML頁面上的“Reset All”功能
      }
  )
  public class DruidStatViewServlet extends StatViewServlet {
  
  }
  

這樣啟動項目后在瀏覽器中輸入地址：端口/druid，就可以看到druid的監控web頁面了

七、 攔截器配置

    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

    @Configuration
    public class WebAppConfigurer extends WebMvcConfigurerAdapter {

        /**
         * 配置攔截器
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // TODO Auto-generated method stub
            // 多個攔截器組成一個攔截器鏈
            // addPathPatterns 用於添加攔截規則
            // excludePathPatterns 用戶排除攔截

            registry.addInterceptor(new AuthInterceptor()).addPathPatterns("/**");


            super.addInterceptors(registry);
        }

        /**
         * 添加自定義的靜態資源映射
          這里使用代碼的方式自定義目錄映射，並不影響Spring Boot的默認映射，可以同時使用。
         */
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {

    //      registry.addResourceHandler("/new/**").addResourceLocations("classpath:/new/");
    //      registry.addResourceHandler("/**").addResourceLocations("/");
            super.addResourceHandlers(registry);
        }

    }

八、swagger發布api測試配置（可忽略）

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;

    import springfox.documentation.builders.ApiInfoBuilder;
    import springfox.documentation.builders.PathSelectors;
    import springfox.documentation.builders.RequestHandlerSelectors;
    import springfox.documentation.service.ApiInfo;
    import springfox.documentation.spi.DocumentationType;
    import springfox.documentation.spring.web.plugins.Docket;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;

    @Configuration
    @EnableSwagger2
    public class Swagger2 {

        @Bean
        public Docket createRestApi(){
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.basePackage("com.zsx.controller.api"))
                    .paths(PathSelectors.any())
                    .build();
        }

        private ApiInfo apiInfo(){
            return new ApiInfoBuilder()
                    .title("Spring Boot中使用Swagger2構建RESTful APIs")
                    .description("描述")
                    .termsOfServiceUrl("http://zsx.com.cn")
                    .version("1.0")
                    .build();
        }

    }

至此，所有的配置已完成，下面是一個操作數據的簡單demo

九、實體類

    @Entity
    @Table(name = "t_user")
    public class Tuser implements java.io.Serializable {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        @Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Long id;

        @Column(name = "username")
        private String userName;

        @Column(name = "password")
        private String passWord;

        @Column(name = "email")
        private String email;

        @Column(name = "mobile")
        private String mobile;

        @Column(name = "nickname")
        private String nickName;

        // 省略getter 和 setter

    }

十、dao層

1、使用jpa基本可以實現不寫sql，（但實際開發中，業務邏輯會很復雜，一點不寫sql完全不現實）

2、注意添加@Repository注解， 添加JpaSpecificationExecutor繼承可以方便分頁

3、 看些jpa的查詢語法資料

    import java.util.List;
    import java.util.Map;

    import org.springframework.data.domain.Pageable;
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.PagingAndSortingRepository;
    import org.springframework.data.repository.query.Param;
    import org.springframework.stereotype.Repository;

    @Repository
    public interface TuserDao extends PagingAndSortingRepository<Tuser, Long>, JpaSpecificationExecutor<Tuser> {

        Tuser findByUserName(String userName);

        @Query("from Tuser t where id = :id")
        List<Tuser> queryFamilyList(@Param("id") Long id, Pageable pageable);

    }

十一、service和controller沒啥好說的，跟原先的一樣，下面再提供一個單元測試的demo

    import java.util.List;
    import javax.persistence.EntityManager;

    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.SpringApplicationConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    import org.springframework.test.context.web.WebAppConfiguration;

    import com.alibaba.fastjson.JSON;
    import com.golden.Application;
    import com.golden.dao.TUserDao;
    import com.golden.entity.Tuser;
    import com.golden.util.GeneratePageable;

    @RunWith(SpringJUnit4ClassRunner.class)

    //指定我們SpringBoot工程的Application啟動類
    @SpringApplicationConfiguration(classes = Application.class)

    //由於是Web項目，Junit需要模擬ServletContext，因此我們需要給我們的測試類加上@WebAppConfiguration
    @WebAppConfiguration
    public class UtilTest {

        @Autowired
        private TUserDao dao;

        @Autowired
        private EntityManager em;

        @Test
        public void test1(){
            dao.findByUserName("admin");
        }

        @Test
        public void test2(){
            // 使用jpa提供的分頁類
            java.util.List<Order> list = new ArrayList<Sort.Order>();
            Order order = new Order(Direction.DESC, "createTime");

            list.add(order);

            Sort sort = new Sort(list);

            Pageable pageable = new PageRequest(0, 10, sort);

            Page<Tuser> findAll = dao.findAll(pageable);

        }

        @Test
        public void test3(){

            EntityManager em = dao.getEntityManager();
            Query query = em.createNativeQuery("select * from t_user limit 1");
            Object singleResult = query.getSingleResult();
            System.out.println(singleResult);
        }

        /*
    //執行原生SQL
    Query nativeQuery = em.createNativeQuery(String sql);
    //指定返回對象類型
    nativeQuery.unwrap(SQLQuery.class).setResultTransformer(Transformers.aliasToBean( Class resultType));
    //返回對象
    List<T> resultList = nativeQuery.getResultList();  
         */
    }

后記：

• 不用Druid的可以把有關Druid的配置全部刪掉，swagger的同理

• 這里沒有使用hibernate.cfg.xml配置文件，主要習慣了在實體類里配置字段了，不怎么用hibernate的映xml文件了，但其實配置起來跟springmvc項目一樣

• 說實話這里使用jpa操作數據庫，沒感覺有多方便，因為總有各種奇葩的需求，當然也可能是我沒深入研究，所以建議改用Mybatis，這個我會再寫一篇springboot加mybatis的配置教程的，最后，還可以使用原生的sql查詢，即使用單元測試里的EntityManager對象去執行sql，返回結果可以指定對象類型，也很方便

• 還需要注意的一個點是靜態文件的存放位置，這個跟原先的項目不一樣，原先是在webapp下，但springboot是默認放在resources下的static目錄下的