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

1、基于springboot-1.4.版本测试

2、springBoot + Hibernate + Druid + Mysql + servlet(jsp)

不废话，直接上代码

一、maven的pom文件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="/POM/4.0.0" xmlns:xsi="http:///2001/XMLSchema-instance"
        xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.">
        <modelVersion>4.0.0</modelVersion>
        <groupId></groupId>
        <artifactId>demo</artifactId>
        <packaging>war</packaging>
        <version>0.0.1</version>
        <name>zsx Maven Webapp</name>
        <url></url>

        <properties>
            <>UTF-8</>
            <>1.7</>
            <>7.0.69</>
        </properties>

        <parent>
            <groupId></groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.</version>
        </parent>

        <dependencies>

            <!-- 添加对jsp视图解析的支持 -->
            <dependency>
                <groupId></groupId>
                <artifactId>tomcat-embed-jasper</artifactId>
            </dependency>
            <dependency>
                <groupId></groupId>
                <artifactId>jstl</artifactId>
            </dependency>


            <dependency>
                <groupId></groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>


            <!-- 下面两个引入为了操作数据库 -->
            <dependency>
                <groupId></groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>



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

            <!-- 只需引入spring-boot-devtools 即可实现热部署 -->
            <dependency>
                <groupId></groupId>
                <artifactId>spring-boot-devtools</artifactId>
            </dependency>

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

            <!-- 为了监控数据库 -->
            <dependency>
                <groupId></groupId>
                <artifactId>druid</artifactId>
                <version>1.0.25</version>
            </dependency>


            <dependency>
                <groupId></groupId>
                <artifactId>poi</artifactId>
                <version>3.14</version>
            </dependency>

            <!-- Junit 单元测试 -->
            <dependency>
                <groupId></groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>

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

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

            <plugins>

                <plugin>
                    <groupId></groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <dependencies>
                        <!-- 热部署 -->
                        <dependency>
                            <groupId></groupId>
                            <artifactId>springloaded</artifactId>
                            <version>1.2.</version>
                        </dependency>
                    </dependencies>
                </plugin>

            </plugins>

        </build>

        <repositories>
            <repository>
                <id>ali</id>
                <name>ali Repository</name>
                <url>/nexus/content/groups/public/</url>
                <snapshots>
                    <enabled>false</enabled>
                </snapshots>
            </repository>
        </repositories>
    </project>

二、项目架构

想想还是介绍一下项目的目录结构，这样方便梳理整体的架构配置

src
├─main
    │  ├─java
    │  │  └─com
    │  │      └─zsx
    │  │          │  
    │  │          │  
    │  │          │  
    │  │          ├─common
    │  │          │  ├─config
    │  │          │  │      
    │  │          │  │      
    │  │          │  │      
    │  │          │  ├─filter
    │  │          │  │      
    │  │          │  │      
    │  │          │  ├─interceptors
    │  │          │  │      
    │  │          │  │      
    │  │          │  │      
    │  │          │  ├─servlet
    │  │          │  │      
    │  │          │  │      
    │  │          │  └─swagger
    │  │          │          
    │  │          │          
    │  │          ├─controller
    │  │          │  │  
    │  │          │  │  
    │  │          │  │  
    │  │          │          
    │  │          ├─dao
    │  │          │  │  
    │  │          │  │  
    │  │          │  └─impl
    │  │          ├─entity
    │  │          │  │  
    │  │          │          
    │  │          ├─model
    │  │          │  │  
    │  │          │          
    │  │          ├─service
    │  │          │  │  
    │  │          │  │  
    │  │          │  └─impl
    │  │          │          
    │  │          │          
    │  │          └─util
    │  │                  
    │  │                  
    │  ├─resources
    │  │  │  
    │  │  │  
    │  │  │  
    │  │  └─static
    │  │      ├─css 
    │  │      ├─img
    │  │      └─js
    │  │                  
    │  └─webapp
    │      │  
    │      │  
    │      └─WEB-INF
    │          │  
    │          │  
    │          └─view
    │              │  
    │              │      
    │              ├─error
    │              │         
    │              ├─jsp
    │                     
    │                      
    └─test
        └─java
                

标准的maven项目结构，其中java下是dao、service、controller ，还有实体类映射entity，其他配置config

三、resources下的应用配置文件

    #=9090


    # 数据库访问配置
    # 主数据源，默认的
    =
    =jdbc:mysql://localhost:3306/test
    = root
    = root
     = 


    # 下面为连接池的补充设置，应用到上面所有数据源中
    # 初始化大小，最小，最大
    =5
    =5
    =20
    # 配置获取连接等待超时的时间
    =60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 
    =60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒 
    =300000
    =SELECT 1 FROM DUAL
    =true
    =false
    =false
    # 打开PSCache，并且指定每个连接上PSCache的大小 
    =true
    =20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙 
    =stat,wall,log4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    ==true;=5000
    # 合并多个DruidDataSource的监控数据
    =true


    #JPA Configuration:  
    =MYSQL
    # Show or not log for each sql query
    -sql=false
    -ddl=true  
    # Hibernate ddl auto (create, create-drop, update)
    -auto=create  
    #-platform=.MySQL5Dialect  
    .naming_strategy=  
    #=.MySQL5InnoDBDialect 
    =.MySQL5Dialect


    =/WEB-INF/view/
    =.jsp
    #-locations=classpath:/resources/,classpath:/static/

四、启动应用主类文件

package ;
import ;
import ;
import ;

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

    public static void main(String[] args) {
        (, args);
    }
}

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

  package ;
  
  import org.;
  import org.;
  import ;
  import ;
  import ;
  /**
   * 修改启动类，继承 SpringBootServletInitializer 并重写 configure 方法
   * @author ZSX
   *
   */
  public class SpringBootStartApplication extends SpringBootServletInitializer {
  
      private static final Logger logger = ();
  
      @Override
      protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
          return ();
      }
  
  }
  

五、数据库连接池Druid的配置

    package ;

    import ;

    import ;

    import ;
    import ;
    import ;
    import ;

    import ;

    /**
     * DruidDBConfig类被@Configuration标注，用作配置信息； 
     * DataSource对象被@Bean声明，为Spring容器所管理， 
     * @Primary表示这里定义的DataSource将覆盖其他来源的DataSource。
     * @author ZSX
     *=${} 
     *最新的支持方式如下: 
     *=@@  
     */
    @Configuration
    public class DruidDBConfig {
    //  private Logger logger = ();

        @Value("${}")
        private String dbUrl;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        @Value("{}")
        private String connectionProperties;

        @Bean // 声明其为Bean实例
        @Primary // 在同样的DataSource中，首先使用被标注的DataSource
        public DataSource dataSource() {
            DruidDataSource datasource = new DruidDataSource();

            ();
            (username);
            (password);
            (driverClassName);

            // configuration
            (initialSize);
            (minIdle);
            (maxActive);
            (maxWait);
            (timeBetweenEvictionRunsMillis);
            (minEvictableIdleTimeMillis);
            (validationQuery);
            (testWhileIdle);
            (testOnBorrow);
            (testOnReturn);
            (poolPreparedStatements);
            (maxPoolPreparedStatementPerConnectionSize);
            try {
                (filters);
            } catch (SQLException e) {

            }
            (connectionProperties);

            return datasource;
        }
    }

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

  import ;
  
  import ;
  import ;
  import ;
  
  @Configuration
  public class MultipartConfig {
  
      @Bean
      public MultipartConfigElement multipartConfigElement(){
          MultipartConfigFactory factory = new MultipartConfigFactory();
          ("10MB");
          ("10MB");
          return ();
      }
  
  }
  

六、开启Druid的数据库监控配置

• 1、配置Filter

  import ;
  import ;
  
  import ;
  
  /**
   * 配置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 ;
  import ;
  
  import ;
  
  
  /**
   * 配置druid监控统计功能
   * 在SpringBoot项目中基于注解的配置，如果是配置，按规则配置即可
   * @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 ;
    import ;
    import ;
    import ;

    @Configuration
    public class WebAppConfigurer extends WebMvcConfigurerAdapter {

        /**
         * 配置拦截器
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            // TODO Auto-generated method stub
            // 多个拦截器组成一个拦截器链
            // addPathPatterns 用于添加拦截规则
            // excludePathPatterns 用户排除拦截

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


            (registry);
        }

        /**
         * 添加自定义的静态资源映射
          这里使用代码的方式自定义目录映射，并不影响Spring Boot的默认映射，可以同时使用。
         */
        @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {

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

    }

八、swagger发布api测试配置（可忽略）

    import ;
    import ;

    import ;
    import ;
    import ;
    import ;
    import ;
    import ;
    import ..EnableSwagger2;

    @Configuration
    @EnableSwagger2
    public class Swagger2 {

        @Bean
        public Docket createRestApi(){
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis((""))
                    .paths(())
                    .build();
        }

        private ApiInfo apiInfo(){
            return new ApiInfoBuilder()
                    .title("Spring Boot中使用Swagger2构建RESTful APIs")
                    .description("描述")
                    .termsOfServiceUrl("")
                    .version("1.0")
                    .build();
        }

    }

至此，所有的配置已完成，下面是一个操作数据的简单demo

九、实体类

    @Entity
    @Table(name = "t_user")
    public class Tuser implements  {

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

        @Id
        @GeneratedValue(strategy=)
        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 ;
    import ;

    import ;
    import ;
    import ;
    import ;
    import ;
    import ;

    @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 ;
    import ;

    import ;
    import ;
    import ;
    import ;
    import .junit4.SpringJUnit4ClassRunner;
    import ;

    import ;
    import ;
    import ;
    import ;
    import ;

    @RunWith()

    //指定我们SpringBoot工程的Application启动类
    @SpringApplicationConfiguration(classes = )

    //由于是Web项目，Junit需要模拟ServletContext，因此我们需要给我们的测试类加上@WebAppConfiguration
    @WebAppConfiguration
    public class UtilTest {

        @Autowired
        private TUserDao dao;

        @Autowired
        private EntityManager em;

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

        @Test
        public void test2(){
            // 使用jpa提供的分页类
            <Order> list = new ArrayList<>();
            Order order = new Order(, "createTime");

            (order);

            Sort sort = new Sort(list);

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

            Page<Tuser> findAll = (pageable);

        }

        @Test
        public void test3(){

            EntityManager em = ();
            Query query = ("select * from t_user limit 1");
            Object singleResult = ();
            (singleResult);
        }

        /*
    //执行原生SQL
    Query nativeQuery = (String sql);
    //指定返回对象类型
    ().setResultTransformer(( Class resultType));
    //返回对象
    List<T> resultList = ();  
         */
    }

后记：

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

• 这里没有使用配置文件，主要习惯了在实体类里配置字段了，不怎么用hibernate的映xml文件了，但其实配置起来跟springmvc项目一样

• 说实话这里使用jpa操作数据库，没感觉有多方便，因为总有各种奇葩的需求，当然也可能是我没深入研究，所以建议改用Mybatis，这个我会再写一篇springboot加mybatis的配置教程的，最后，还可以使用原生的sql查询，即使用单元测试里的EntityManager对象去执行sql，返回结果可以指定对象类型，也很方便

• 还需要注意的一个点是静态文件的存放位置，这个跟原先的项目不一样，原先是在webapp下，但springboot是默认放在resources下的static目录下的，还有其他默认目录和配置，自行搜索

• 时间仓促，以后再补充