Spring Boot + Jpa(Hibernate) 架構(gòu)基本配置詳解

更新時間：2017年05月19日 14:59:45 作者：Hgihness

本篇文章主要介紹了Spring Boot + Jpa(Hibernate) 架構(gòu)基本配置詳解，具有一定的參考價值，感興趣的小伙伴們可以參考一下

1、基于springboot-1.4.0.RELEASE版本測試

2、springBoot + hibernate + Druid + MySQL + servlet(jsp)

不廢話，直接上代碼

一、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>


      <!-- 下面兩個引入為了操作數(shù)據(jù)庫 -->
      <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 即可實現(xiàn)熱部署 -->
      <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>

      <!-- 為了監(jiān)控數(shù)據(jù)庫 -->
      <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>

二、項目架構(gòu)

想想還是介紹一下項目的目錄結(jié)構(gòu)，這樣方便梳理整體的架構(gòu)配置

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項目結(jié)構(gòu)，其中Java下是dao、service、controller ，還有實體類映射entity，其他配置config

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

  #server.port=9090


  # 數(shù)據(jù)庫訪問配置
  # 主數(shù)據(jù)源，默認的
  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


  # 下面為連接池的補充設置，應用到上面所有數(shù)據(jù)源中
  # 初始化大小，最小，最大
  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
  # 配置監(jiān)控統(tǒng)計攔截的filters，去掉后監(jiān)控界面sql無法統(tǒng)計，'wall'用于防火墻 
  spring.datasource.filters=stat,wall,log4j
  # 通過connectProperties屬性來打開mergeSql功能；慢SQL記錄
  spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
  # 合并多個DruidDataSource的監(jiān)控數(shù)據(jù)
  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);
  }

}

五、數(shù)據(jù)庫連接池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的數(shù)據(jù)庫監(jiān)控配置

1、配置Filter

import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;

import com.alibaba.druid.support.http.WebStatFilter;

/**
 * 配置druid監(jiān)控統(tǒng)計功能
 * 配置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監(jiān)控統(tǒng)計功能
 * 在SpringBoot項目中基于注解的配置，如果是web.xml配置，按規(guī)則配置即可
 * @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優(yōu)先于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的監(jiān)控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 用于添加攔截規(guī)則
      // excludePathPatterns 用戶排除攔截

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


      super.addInterceptors(registry);
    }

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

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

  }

八、swagger發(fā)布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構(gòu)建RESTful APIs")
          .description("描述")
          .termsOfServiceUrl("http://zsx.com.cn")
          .version("1.0")
          .build();
    }

  }

至此，所有的配置已完成，下面是一個操作數(shù)據(jù)的簡單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基本可以實現(xiàn)不寫sql，（但實際開發(fā)中，業(yè)務邏輯會很復雜，一點不寫sql完全不現(xiàn)實）

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);
    }

    /*
  //執(zhí)行原生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操作數(shù)據(jù)庫，沒感覺有多方便，因為總有各種奇葩的需求，當然也可能是我沒深入研究，所以建議改用Mybatis，這個我會再寫一篇springboot加mybatis的配置教程的，最后，還可以使用原生的sql查詢，即使用單元測試里的EntityManager對象去執(zhí)行sql，返回結(jié)果可以指定對象類型，也很方便

還需要注意的一個點是靜態(tài)文件的存放位置，這個跟原先的項目不一樣，原先是在webapp下，但springboot是默認放在resources下的static目錄下的，還有其他默認目錄和配置，自行搜索

以上就是本文的全部內(nèi)容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章:

dubbo?filter中有關bean注入和配置文件讀取方式
這篇文章主要介紹了dubbo?filter中有關bean注入和配置文件讀取方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
2024-05-05
詳解springmvc攔截器攔截靜態(tài)資源
本篇文章主要介紹了詳解springmvc攔截器攔截靜態(tài)資源，具有一定的參考價值，感興趣的小伙伴們可以參考一下。
2017-01-01
Java設置Map過期時間的的幾種方法舉例詳解
本文詳細介紹了Java中使用輕量級緩存組件ExpiringMap以及Guava的LoadingCache緩存機制,ExpiringMap提供了Map自動過期、監(jiān)聽事件等功能,而LoadingCache提供了緩存回收、數(shù)據(jù)加載等高級功能,兩者為Java項目提供了有效的數(shù)據(jù)管理和緩存解決方案,需要的朋友可以參考下
2024-10-10
Java中TreeSet、HashSet、Collection重寫比較器的實現(xiàn)
比較器是一種可以對集合或數(shù)組中的元素按照自定義的方式進行排序的對象,本文主要介紹了Java中TreeSet、HashSet、Collection重寫比較器的實現(xiàn),具有一定的參考價值,感興趣的小伙伴們可以參考一下
2023-08-08
SpringBoot如何使用MyBatis-Plus實現(xiàn)高效的數(shù)據(jù)訪問層
在開發(fā) Spring Boot 應用時,數(shù)據(jù)訪問是不可或缺的部分,本文將詳細介紹如何在 Spring Boot 中使用 MyBatis-Plus,并結(jié)合具體代碼示例來講解它的使用方法和常見配置,希望對大家有一定的幫助
2025-04-04
Spring注入值到Bean的三種方式
這篇文章主要為大家詳細介紹了Spring注入值到Bean的三種方式，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2017-07-07
Java?RabbitMQ消息隊列詳解常見問題
消息隊列是最古老的中間件之一，從系統(tǒng)之間有通信需求開始，就自然產(chǎn)生了消息隊列。本文告訴什么是消息隊列，為什么需要消息隊列，常見的消息隊列有哪些，RabbitMQ的部署和使用
2022-07-07
解決Java Redis刪除HashMap中的key踩到的坑
這篇文章主要介紹了解決Java Redis刪除HashMap中的key踩到的坑，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2021-02-02
springboot中手動提交事務的實現(xiàn)方法
手動提交事務可以提供更靈活的控制,以便在分布式環(huán)境中處理事務的提交和回滾,本文就來介紹一下springboot中手動提交事務的實現(xiàn)方法,感興趣的可以了解一下
2024-01-01
SpringBoot整合MyBatis-Plus3.1教程詳解
這篇文章主要介紹了SpringBoot整合MyBatis-Plus3.1詳細教程，非常不錯，具有一定的參考借鑒價值,需要的朋友可以參考下
2019-08-08