SpringBoot + Jpa(Hibernate) 架构基本配置
1、基于springboot-1.4.0.RELEASE版本测试
2、springBoot + Hibernate + Druid + Mysql + servlet(jsp)
一、maven的pom文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
<?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" <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> |
二、项目架构
想想还是介绍一下项目的目录结构,这样方便梳理整体的架构配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
#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
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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容器中,则添加下面类即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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的配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
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,
修改用下面的配置类:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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页面了
七、 拦截器配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
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测试配置(可忽略)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
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( "描述" ) .version( "1.0" ) .build(); } } |
至此,所有的配置已完成,下面是一个操作数据的简单demo
九、实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
@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的查询语法资料
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
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目录下的,还有其他默认目录和配置.
SpringBoot + Jpa(Hibernate) 架构基本配置的更多相关文章
- Spring Boot + Jpa(Hibernate) 架构基本配置
本文转载自:https://blog.csdn.net/javahighness/article/details/53055149 1.基于springboot-1.4.0.RELEASE版本测试 2 ...
- springmvc+spring+jpa(hibernate)+redis+maven配置
废话不多少 项目结构 pom.xml配置例如以下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=& ...
- SpringBoot Jpa 分页查询最新配置方式
这是已经被废弃的接口 Sort sort = new Sort(Sort.Direction.DESC,"bean类中字段"); //创建时间降序排序 Pageable pagea ...
- SpringBoot +Jpa+ Hibernate+Mysql工程
1 使用工具workspace-sts 3.9.5.RELEASE (1)新建一个SpringBoot 项目,选择加载项目需要的的组件.DevTools,JPA,Web,Mysql. Finish. ...
- Springboot spring data jpa 多数据源的配置01
Springboot spring data jpa 多数据源的配置 (说明:这只是引入了多个数据源,他们各自管理各自的事务,并没有实现统一的事务控制) 例: user数据库 global 数据库 ...
- SpringBoot之使用jpa/hibernate
Springboot版本是2.1.3.RELEASE 1.依赖 List-1.1 <dependency> <groupId>org.springframework.boot& ...
- SpringMVC+Apache Shiro+JPA(hibernate)整合配置
序: 关于标题: 说是教学,实在愧不敢当,但苦与本人文笔有限,实在找不到更合理,谦逊的词语表达,只能先这样定义了. 其实最真实的想法,只是希望这个关键词能让更多的人浏览到这篇文章,也算是对于自己写文章 ...
- Spring4.x Jpa + hibernate的配置(废弃JpaTemplate)
近年来 ORM(Object-Relational Mapping,对象关系映射,即实体对象和数据库表的映射)技术市场热闹非凡,各种各样的持久化框架应运而生,其中影响最大的是 Hibernate 和 ...
- springboot 集成 jpa/hibernate
pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId> ...
随机推荐
- DataTable转成List
DataTable转成List //把一个Datatable 赋值给一个List对象 //定义一个转换类 public class ConvertTool { public static List&l ...
- 定时清理docker私服镜像
定时清理docker私服镜像 使用CI构建docker镜像进行发布极大促进了大家的版本发布效率,于是镜像仓库也就急速膨胀.为了缓解磁盘压力,我们需要设置一些清理策略. 对于不同docker镜像的清理策 ...
- JS 一些有意思的写法
对于 C语言中的 &&(有一个为假,返回的为false) 和 || (有一个为真,即为真),但是对于 JS中的 && 和 || 运算是有所不同的. 详情见下面: &am ...
- Container及其内部进程监控剖析
目前市场上的虚拟化技术种类很多,例如moby(docker).LXC.RKT等等.在带来方便应用部署和资源充分利用的好处的同时,如何监控相应Container及其内部应用进程成为运维人员不可避免遇到的 ...
- 朴素贝叶斯python代码实现(西瓜书)
朴素贝叶斯python代码实现(西瓜书) 摘要: 朴素贝叶斯也是机器学习中一种非常常见的分类方法,对于二分类问题,并且数据集特征为离散型属性的时候, 使用起来非常的方便.原理简单,训练效率高,拟合效果 ...
- DFS树求割点问题
时间复杂度:O(n玄学)总之不大 代码实现(好麻烦,蓝题变紫题) #include<iostream> #include<string.h> #include<algor ...
- 线程的start方法解析
Thread是学习我们学习多线程接触到的第一个有关多线程的类,相信每一个学习过或者了解过Java多线程的小伙伴都知道Thread类.这次分享主要对Thread的start方法进行讲解. 相信大家都知道 ...
- js设置,取得,清除cookie
//取得cookie function getCookie(name) { var nameEQ = name + "="; var ca = document.cookie. ...
- Zabbix-3.4快速安装
过多的介绍不写了,本篇文章主要是快速安装下zabbix服务,如果不知道zabbix监控原理,可以先去了解下. 用的是Centos7.2系统安装的zabbix-3.4 1.下载Zabbix-releas ...
- python 13 内置函数2
目录 内置函数(二) 匿名函数 内置函数(三) 闭包 内置函数(二) abs() #返回绝对值--返回的是正数 enumerate("可迭代对象","序号起始值" ...