本文共 24659 字,大约阅读时间需要 82 分钟。
Spring Boot是Spring项目中的一个子工程,与我们所熟知的Spring-framework 同属于spring的产品:
首页Spring Boot简介可以看到下面的一段介绍:一般把Spring Boot称为搭建程序的 脚手架 或者说
发人员快速的构建庞大的spring项目,并且尽可能的减少一切xml配置,做到开箱即用,迅速上手,让开发人员关注业务而非配置。是便捷搭建 基于Spring的工程 脚手架
。其最主要作用就是帮助开
学习目标:了解Spring Boot是什么,有什么作用
总结:
Spring Boot是一个便捷搭建 基于spring工程的脚手架;作用是帮助开发人员快速搭建大型的spring 项目。简化工程的配置,依赖管理;实现开发人员把时间都集中在业务开发上。
java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时,可能Python程序员已经把功能写好了,
究其原因注意是两点:
复杂的配置
项目各种配置其实是开发时的损耗, 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换,所以写配置挤占了写应用程序逻辑的时间。
一个是混乱的依赖管理
项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了,你还要知道这些库的哪个版本和其他库不会有冲突,这难题实在太棘手。并且,依赖管理也是一种损耗,添加依赖不是写应用程序代码。一旦选错了依赖的版本,随之而来的不兼容问题毫无疑问会是生产力杀手。
而Spring Boot让这一切成为过去!
Spring Boot 简化了基于Spring的应用开发,只需要“run”就能创建一个独立的、生产级别的Spring应用。
Spring Boot为Spring平台及第三方库提供开箱即用的设置(提供默认设置,存放默认配置的包就是启动器starter),这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。
我们可以使用Spring Boot创建java应用,并使用java –jar 启动它,就能得到一个生产级别的web工程。
学习目标:能够使用Spring Boot搭建项目
解析:
需求:可以在浏览器中访问http://localhost:8080/hello输出一串字符
实现步骤:
创建工程;
添加依赖(启动器依赖,spring-boot-starter-web);
pom.xml
4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.5.RELEASE com.heiheihei heiheiheispringboot 1.0-SNAPSHOT 1.8 org.springframework.boot spring-boot-starter-web
创建启动类;
package com.heiheihei;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/28 20:56 *//** * spring boot工程都有一个启动引导类,这是工程的人口类 * 并在引导类上添加@SpringBootApplication */@SpringBootApplicationpublic class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }}
创建处理器Controller;
package com.heiheihei.controller;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/28 21:07 */@RestControllerpublic class HelloController { @GetMapping("hello") public String hello() { return "hello, Spring Boot!"; }}
测试
总结:Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。
spring-boot-starter-web默认的应用服务器端口是8080
Spring Boot 主要特点是:
更多细节,大家可以到官网查看。
学习目标:可以使用@Value获取配置文件配置项并结合@Bean注册组件到Spring
解析:
需求:使用Java代码配置数据库连接池,并可以在处理器中注入并使用
步骤:
添加依赖
com.alibaba druid 1.1.6
创建数据库;
创建数据库连接参数的配置文件jdbc.properties
jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://127.0.0.1:3306/springboot_testjdbc.username=rootjdbc.password=root
创建配置类
package com.heiheihei.config;import com.alibaba.druid.pool.DruidDataSource;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.PropertySource;import javax.sql.DataSource;@Configuration@PropertySource("classpath:jdbc.properties")public class JdbcConfig { @Value("${jdbc.url}") String url; @Value("${jdbc.driverClassName}") String driverClassName; @Value("${jdbc.username}") String username; @Value("${jdbc.password}") String password; @Bean //注入IOC容器中时默认id为方法名 public DataSource dataSource(){ DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(driverClassName); dataSource.setUrl(url); dataSource.setUsername(username); dataSource.setPassword(password); return dataSource; }}
改造处理器类注入数据源并使用
package com.heiheihei.controller;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import javax.sql.DataSource;/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/28 21:07 */@RestControllerpublic class HelloController { @Autowired private DataSource dataSource; @GetMapping("hello") public String hello() { System.out.println("dataSource = " + dataSource); return "hello, Spring Boot!"; }}
总结:
使用@Configuration标识配置类,使用@PropertySource(“classpath:jdbc.properties”)进行引入文件,使用@Value进行注入.使用@Bean将方法返回值注入Spring容器.
学习目标:能够使用@ConfigurationProperties
实现Spring Boot配置文件配置项读取和应用
解析:
需求:将配置文件中的配置项读取到一个对象中;
实现:可以使用Spring Boot提供的注解@ConfigurationProperties
,该注解可以将Spring Boot的配置文件(默认必须为application.properties或application.yml)中的配置项读取到一个对象中。
实现步骤:
创建配置项类JdbcProperties类,在该类名上面添加@ConfigurationProperties
;
package com.heiheihei.config;import org.springframework.boot.context.properties.ConfigurationProperties;/** * ConfigurationProperties从application配置文件中读取配置项 * prefix表示配置的前缀 * 配置选类中的类变量必须要与前缀之后的配置项名称保持 松散绑定(相同) */@ConfigurationProperties(prefix = "jdbc")public class JdbcProperties { private String url; private String driverClassName; private String username; private String password; //生成get和set方法}
将jdbc.properties修改名称为application.properties;
将JdbcProperties对象注入到JdbcConfig;
方式一
/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/28 21:44 */@Configuration@EnableConfigurationProperties(JdbcProperties.class)public class JdbcConfig { /** * 在可能需要多个Bean使用,使用该方式,并在类上添加@EnableConfigurationProperties(JdbcProperties.class)进行注入 * * @param jdbcProperties * @return */ @Bean public DataSource dataSource(JdbcProperties jdbcProperties) { DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(jdbcProperties.getDriverClassName()); dataSource.setUrl(jdbcProperties.getUrl()); dataSource.setUsername(jdbcProperties.getUsername()); dataSource.setPassword(jdbcProperties.getPassword()); return dataSource; }}
注意:该方法需要配置项类和在注入的类中添加@EnableConfigurationProperties(JdbcProperties.class)
注解,并且需要在pom.xml中添加<artifactId>spring-boot-configuration-processor</artifactId>
方式二(无需配置项类JdbcProperties
),Spring Boot默认注入了application.properties
/** * 如果一段属性只有一个Bean需要使用,我们无需将其注入到一个类(JdbcProperties,将该类上的所有注 * 解去掉)中。而是直接在需要的地方声明即可 * * @return */@Bean@ConfigurationProperties(prefix = "jdbc")public DataSource dataSource() { return new DruidDataSource();}
注意:我们直接把@ConfigurationProperties(prefix = "jdbc")
声明在需要使用的 @Bean
的方法上,然后Spring Boot就会自动调用这个Bean(此处是DataSource)的set方法,然后完成注入。使用的前提是:该类必须有对应属性的set方法!
测试
总结:
第一种:使用@ConfigurationProperties
编写配置项类将配置文件中的配置项设置到对象中
@ConfigurationProperties(prefix = "jdbc")public class JdbcProperties { private String url; private String driverClassName; private String username; private String password; public String getUrl() { return url; } public void setUrl(String url) { this.url = url; } public String getDriverClassName() { return driverClassName; } public void setDriverClassName(String driverClassName) { this.driverClassName = driverClassName; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; }}
并在在pom.xml中添加坐标<artifactId>spring-boot-configuration-processor</artifactId>
,再在需要使用引入的值的类中进行添加@EnableConfigurationProperties(JdbcProperties.class)
@Beanpublic DataSource dataSource(JdbcProperties jdbcProperties) { DruidDataSource dataSource = new DruidDataSource(); dataSource.setDriverClassName(jdbcProperties.getDriverClassName()); dataSource.setUrl(jdbcProperties.getUrl()); dataSource.setUsername(jdbcProperties.getUsername()); dataSource.setPassword(jdbcProperties.getPassword()); return dataSource;}
使用形参进行获取被设置的对象(实际上是根据类类型从SpringIOC容器获取的)
使用@ConfigurationProperties
在方法上面使用,无需编写配置项类,但是properties文件名为application.properties
,Spring Boot 默认注入了application.properties
文件
@Bean@ConfigurationProperties(prefix = "jdbc")public DataSource dataSource() { return new DruidDataSource();}
prefix
为匹配文件中的前缀,如jdbc.url
,然后url匹配需要注入的setUrl()
方法
注意:@ConfigurationProperties
类似于依赖注入Set方式进行对类(变量的set方法)或方法(根据返回类型的对象变量)进行注入数据(读取appliation.ylm或propertis文件到对象中)
配置文件除了可以使用application.properties类型,还可以使用后缀名为:.yml或者.yaml的类型,也就是:application.yml或者application.yaml
正如TAML所表示的YAML Ain’t Markup Language, YAML是一个简洁的非标记语言.YAML以数据为中心,使用空白缩进,分行组织数据,从而使得表示更加简洁易读.
学习目标:可以将多个yml文件在application.yml文件中配置激活
解析:
yaml与properties配置文件除了展示形式不相同以外,其它功能和作用都是一样的;在项目中原路的读取方式不需要改变。
yml配置文件的特征:
:
之后空一格再写配置项值;将application.properties配置文件修改为application.yml的话:
如果两个配置文件都有,会把两个文件的配置合并,如果有重复属性,以properties中的为准。
jdbc: driverClassName: com.mysql.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/heiheihei username: root password: rootkey: abc: cba def: - g - h - j
这里有两组无关系配置项
如果是配置数组、list、set等结构的内容,那么在yml文件中格式为:
key: - value1 - value2
多个yml配置文件;在spring boot中是被允许的。这些配置文件的名称必须为application-***.yml
,并且这些配置文件必须要在application.yml配置文件中激活之后才可以使用。
在多个配置文件时,需要将这些文件在application.yml文件中进行激活:
#激活配置文件;需要指定其它的配置文件名称spring: profiles: active: abc,def
多个文件名只需要写application-之后的名称,在多个文件之间使用,隔开。
创建 application-abc.yml 文件如下:
heiheihei:url: http://www.heiheihei.cn
创建 application-def.yml 文件如下:
heiheihei:url: http://www.hahaha.com
如果properties和yml配置文件同时存在在spring boot项目中;那么这两类配置文件都有效。在两个配置文件中如果存在同名的配置项的话会以properties文件的为主。
修改代码测试:
结果使用Spring Boot之后,一个整合了SpringMVC的WEB工程开发,变的无比简单,那些繁杂的配置都消失不见了,这是如何做到的?
一切魔力的开始,都是从我们的main函数来的,所以我们再次来看下启动类:
我们发现特别的地方有两个:@SpringBootApplication
SpringApplication.run()
由于流程比较复杂,在这不做解释
简化流程描述:
SpringBoot为我们提供了默认配置,而默认配置生效的步骤(重点):
@EnableAutoConfiguration
注解会去寻找META-INF/spring.factories
文件,读取其中以 EnableAutoConfiguration
为key的所有类的名称,这些类就是提前写好的自动配置类@Configuration
注解,并且通过 @Bean
注解提前配置了我们所需要的一切实例@ConditionalOn
注解,满足一定条件才会生效。 比如条件之一: 是一些相关的类要存在Bean
,那么会覆盖默认的自动配置的Beanapplication.yml
文件,来覆盖自动配置中的属性属性文件支持两种格式,application.properties
和application.yml
,如果properties和yml文件都存在,如果有重叠属性,默认以Properties
优先。
学习目标:了解Spring Boot项目的配置加载流程
解析:
META-INF\spring.factories
文件中定义了很多自动配置类;可以根据在pom.xml文件中添加的 启动器依赖自动配置组件我们编写pojo时,经常需要编写构造函数和getter、setter方法,属性多的时候,就非常浪费时间,使用lombok插件可以解决这个问题:
在IDEA中安装lombok插件;不安装插件在IDEA中使用lombok的注解虽然编译能通过,但是源码会报错。所以为了让IDEA更好的辨别lombok注解则才安装插件。
需要在maven工程中的 pom.xml 文件引入依赖:
org.projectlombok lombok
然后可以在Bean上使用:
@Data :自动提供getter和setter、hashCode、equals、toString等方法 @Getter:自动提供getter方法 @Setter:自动提供setter方法 @Slf4j:自动在bean中提供log变量,其实用的是slf4j的日志功能。学习目标:使用lombok的注解实现pojo类的简化
解析:
使用Spring Boot整合SSM工程;需要使用到数据库数据。
将数据库表数据导入到数据库中(springboot_test);
编写数据库表对应的实体类;一般情况下需要编写get/set/toString
等这些方法会耗时并且会让实体类看起来比较臃肿。可以使用lombok
插件对实体类进行简化。
lombok是一个插件工具类包;提供了一些注解@Data、@Getter
等这些注解去简化实体类中的构造方法、get/set
等方法的编写。
在IDEA中安装lombok插件;
添加lombok对应的依赖到项目pom.xml文件;
org.projectlombok lombok
改造实体类使用lombok注解
package com.heiheihei.pojo;import lombok.Data;import lombok.extern.slf4j.Slf4j;import java.util.Date;/** * 用户实体类 * 在编译阶段根据注解自动生成对应的方法;data包含 * get/set/hashCode/equals/toString等方法 * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/29 18:37 */@Data@Slf4jpublic class User { private Integer id; private String userName; private String password; private String name; private Integer age; private Integer sex; private Date birthday; private String note; private Date created; private Date updated;}
引入@Slf4j
是为了使用log对象
虽然默认配置已经可以使用
SpringMVC
了,不过我们有时候需要进行自定义配置。
可以在 application.yml
文件中配置日志级别控制:
logging: level: com.heiheihei: debug org.springframework: info
查看SpringBoot的全局属性可知,端口通过以下方式配置
修改 application.yml 配置文件,添加如下配置:# 映射端口server: port: 80
访问静态资源
现在,我们的项目是一个jar工程,那么就没有webapp,我们的静态资源该放哪里呢?有一个叫做ResourceProperties的类,里面就定义了静态资源的默认查找路径:
在spring boot项目中静态资源可以放置在如下目录:
默认的静态资源路径为:
classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public/
只要静态资源放在这些目录中任何一个,SpringMVC都会帮我们处理。
我们习惯会把静态资源放在 classpath:/static/ 目录下。
目标:可以修改tomcat的端口和访问项目中的静态资源
解析:
修改tomcat端口
查询**Properties,设置配置项(前缀+类变量名)到application配置文件中
#tomcat端口server: port: 80
访问项目中的静态资源
静态资源放置的位置;放置静态资源并访问这些资源
拦截器也是我们经常需要使用的,在SpringBoot中该如何配置呢?
拦截器不是一个普通属性,而是一个类,所以就要用到java配置方式了。在SpringBoot官方文档中有这么一段说明:
翻译:如果你想要保持Spring Boot 的一些默认MVC特征,同时又想自定义一些MVC配置(包括:拦截器,格式化器,视图控制器、消息转换器 等等),你应该让一个类实现
WebMvcConfigurer
,并且添加@Configuration
注解,但是千万不要加@EnableWebMvc
注解。如果你想要自定义HandlerMapping
、HandlerAdapter
、ExceptionResolver
等组件,你可以创建一个WebMvcRegistrationsAdapter
实例 来提供以上组件。如果你想要完全自定义SpringMVC,不保留SpringBoot提供的一切特征,你可以自己定义类并且添加@Configuration
注解和@EnableWebMvc
注解
总结:通过实现 WebMvcConfigurer
并添加@Configuration
注解来实现自定义部分SpringMvc配置。
目标:可以在Spring Boot项目中配置自定义SpringMVC拦截器
分析:
编写拦截器(实现HandlerInterceptor)
书写interceptor
/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/29 19:56 */@Slf4jpublic class Myinterceptor implements HandlerInterceptor { /** * 执行处理器前 * * @param request * @param response * @param handler * @return * @throws Exception */ @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { log.debug("这是Myinterceptor的preHandle方法"); return true; } /** * 执行处理器之后 * * @param request * @param response * @param handler * @param modelAndView * @throws Exception */ @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { log.debug("这是Myinterceptor的postHandle方法"); } /** * 渲染页面后 * * @param request * @param response * @param handler * @param ex * @throws Exception */ @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { log.debug("这是Myinterceptor的afterCompletion方法"); }}
可以使用@Component进行注入SpringIOC容器.
编写配置类实现 WebMvcConfigurer
,在该类中添加各种组件;
配置interceptor
/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/29 20:08 */@Configurationpublic class MvcConfig implements WebMvcConfigurer { /** * 注册拦截器 * * @return */ @Bean public Myinterceptor myinterceptor() { return new Myinterceptor(); } /** * 添加拦截器spring MVC的拦截器链 * * @param registry */ @Override public void addInterceptors(InterceptorRegistry registry) { //注册拦截器,与配置拦截路径 registry.addInterceptor(myinterceptor()).addPathPatterns("/*"); }}
可以使用@Autowired
进行注入
测试
类似于书写interceptor以及配置interceptor
其实,在刚才引入jdbc启动器的时候,SpringBoot已经自动帮我们引入了一个连接池:
HikariCP应该是目前速度最快的连接池了,我们看看它与c3p0的对比: 因此,我们只需要指定连接池参数即可;打开 application.yml 添加修改配置如下:spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://localhost:3306/springboot_test username: root password: root
注意:使用默认的连接池需要把配置了其他的连接池的jdbcConfig类内的其他连接池进行注释或删除
学习目标:配置Spring Boot自带默认的hikari数据库连接池和使用@Transactional注解进行事务配置
问题: 事务失效(原因:事务方法嵌套||private方法进行事务管理)动态代理的问题(cglib方式)
解析:
事务配置
添加事务相关的启动器依赖,mysql相关依赖;
org.springframework.boot spring-boot-starter-jdbc mysql mysql-connector-java 5.1.46
编写业务类UserService使用事务注解@Transactional
@Transactionalpublic void saveUser(User user) { ....}
数据库连接池hikari配置
只需要在application配置文件中指定数据库相关参数
spring: datasource: driver-class-name: com.mysql.jdbc.Driver url: jdbc:mysql://127.0.0.1:3306/springboot_test username: root password: root
总结
SpringBoot官方并没有提供Mybatis的启动器,不过Mybatis官网自己实现了。在项目的 pom.xml 文件中加入如下依赖:
org.mybatis.spring.boot mybatis-spring-boot-starter 2.0.1
配置 application.yml ,常用配置如下:
# mybatis配置mybatis: # 实体类别名包路径 type-aliases-package: com.heiheihei.pojo # 映射文件路径 # mapper-locations: classpath:mapper/*.xml configuration: # 控制台输出执行sql log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
配置Mapper扫描
需要注意,这里没有配置mapper接口扫描包,因此我们需要给每一个Mapper接口添加 @Mapper 注解,才能被识别。
@Mapperpublic interface UserMapper { }
或者,我们也可以不加注解,而是在启动类上添加扫描包注解(推荐):
@SpringBootApplication@MapperScan("com.heiheihei.mapper")public class Application { public static void main(String[] args) { // 启动代码 SpringApplication.run(Application.class, args); }}
学习目标:配置Mybatis在Spring Boot工程中的整合包,设置mybatis的实体类别名,输出执行sql语句配置项
解析:
通用Mapper的作者也为自己的插件编写了启动器,我们直接引入即可。在项目的 pom.xml 文件中加入如下依赖:
tk.mybatis mapper-spring-boot-starter 2.1.5
注意:一旦引入了通用Mapper的启动器,会覆盖Mybatis官方启动器的功能,因此需要移除对官方Mybatis启动器的依赖
编写XXXMapper(XXXDao)
无需任何配置就可以使用了。如果有特殊需要,可以到通用mapper官网查看:,但是需要继承Mapper类例如:
package com.heiheihei.mapper;import com.heiheihei.pojo.User;import tk.mybatis.mapper.common.Mapper;public interface UserMapper extends Mapper{ }
把启动类上的@MapperScan
注解修改为通用mapper中自带(tk包下
)的:
在实体类上加JPA注解
例如:
package com.heiheihei.pojo;import lombok.Data;import lombok.extern.slf4j.Slf4j;import tk.mybatis.mapper.annotation.KeySql;import javax.persistence.Column;import javax.persistence.Id;import javax.persistence.Table;import java.util.Date;/** * 用户实体类 * 在编译阶段根据注解自动生成对应的方法;data包含get/set/hashCode/equals/toString等方法 * * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/29 18:37 */@Data@Table(name = "tb_user")public class User { @Id //开启主键回填 @KeySql(useGeneratedKeys = true) private Integer id; //与数据库的字段进行匹配,在表中所有"_" 使用驼峰命名法如user_name-->userName //@Column private String userName; private String password; private String name; private Integer age; private Integer sex; private Date birthday; private String note; private Date created; private Date updated;}
对 Service 的代码进行简单改造
/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/29 20:35 */@Servicepublic class UserService { @Autowired private UserMapper userMapper; public User queryById(Integer id) { return userMapper.selectByPrimaryKey(id); } @Transactional public void saveUser(User user) { userMapper.insertSelective(user); }}
selectByPrimaryKey
根据主键查询
insertSelective
选择性插入表 ,未赋值的属性将不进行插入操作. selectByPrimaryKey等方法通过动态代理生成
学习目标:配置通用Mapper组件到Spring Boot项目中并使用Mapper接口
解析:
通用Mapper:可以实现自动拼接sql语句;所有的mapper都不需要编写任何方法也就是不用编写sql语句。可以提高开发效率。
Mapper<User>
;注意要点:
在启动引导类上面的mapper扫描注解 一定要修改为 通用mapper的扫描注解
目标:可以访问处理器对应路径将数据库中的数据根据id查询
分析:
小结:
修改了HelloController:
@Autowired private UserService userService; /** * 根据用户id查询用户 * @param id 用户id * @return 用户 */ @GetMapping("/user/{id}") public User queryById(@PathVariable Long id){ return userService.queryById(id); }
在springboot项目中如果要使用Junit进行单元测试,则需要添加如下的依赖:
org.springframework.boot spring-boot-starter-test
在测试包下编写测试类,使用Ctrl+Shift+T
生成测试类,注意勾选测试方法.
@SpringBootTest
注解。 例如:
/** * @author 嘿嘿嘿1212 * @version 1.0 * @date 2019/10/30 9:53 */@RunWith(SpringRunner.class)@SpringBootTestpublic class UserServiceTest { @Autowired private UserService userService; @Test public void queryById() { User user = userService.queryById(8); System.out.println("user = " + user); } @Test public void saveUser() { User user = new User(); user.setUserName("test2"); user.setName("魔鬼2号"); user.setAge(18); user.setPassword("10086"); user.setSex(1); user.setCreated(new Date()); userService.saveUser(user); }}
测试代码路径结构:
学习目标:在Spring Boot项目中使用Junit进行单元测试Service的方法
解析:
在Spring Boot项目中如果编写测试类则必须要在类上面添加@SpringBootTest与@RunWith(SpringRunner.class)
在 pom.xml 文件中添加如下依赖
org.springframework.boot spring-boot-starter-data-redis
配置 application.yml 文件
spring: redis: host: localhost port: 6379
测试:
@RunWith(SpringRunner.class)@SpringBootTestpublic class RedisTest { @Autowired private RedisTemplate redisTemplate; @Test public void test(){ //string 字符串 //redisTemplate.opsForValue().set("str", "heiheihei"); redisTemplate.boundValueOps("str").set("heiheihei"); System.out.println("str = " + redisTemplate.opsForValue().get("str")); //hash 散列 redisTemplate.boundHashOps("h_key").put("name", "heiheihei"); redisTemplate.boundHashOps("h_key").put("age", 13); //获取所有域 Set set = redisTemplate.boundHashOps("h_key").keys(); System.out.println(" hash散列的所有域:" + set); //获取所有值 List list = redisTemplate.boundHashOps("h_key").values(); System.out.println(" hash散列的所有域的值:" + list); //list 列表 redisTemplate.boundListOps("l_key").leftPush("c"); redisTemplate.boundListOps("l_key").leftPush("b"); redisTemplate.boundListOps("l_key").leftPush("a"); //获取全部元素 list = redisTemplate.boundListOps("l_key").range(0, -1); System.out.println(" list列表中的所有元素:" + list); // set 集合 redisTemplate.boundSetOps("s_key").add("a", "b", "c"); set = redisTemplate.boundSetOps("s_key").members(); System.out.println(" set集合中的所有元素:" + set); // sorted set 有序集合 redisTemplate.boundZSetOps("z_key").add("a", 30); redisTemplate.boundZSetOps("z_key").add("b", 20); redisTemplate.boundZSetOps("z_key").add("c", 10); set = redisTemplate.boundZSetOps("z_key").range(0, -1); System.out.println(" zset有序集合中的所有元素:" + set); }}
学习目标:在Spring Boot项目中使用Junit测试RedisTemplate的使用
解析:
spring-boot-starter-data-redis
application.yml
中修改redis的连接参数;(redis需要启动)RedisTemplate
操作redis中的5种数据类型(string/hash/list/set/sorted set
)添加项目的pom.xml插件;在pom.xml要显式的加入插件spring-boot-maven-plugin
,否则无法产生 jar 清单文件,导致打出来的 jar 无法使用命令运行
org.springframework.boot spring-boot-maven-plugin
使用maven的命令package打包;(test比较耗时,无错误的时候可以禁用)
之后在项目下的 target 目录中将有如下jar包:【注意】在查看打出的 jar 的时候,将发现 jar 包里面包含 jar 包;这样的包称为 fatJar(肥包)
运行
运行打出来的包:
使用命令:java –jar
包全名
或者写一个 bat
文件,里面包含 java –jar
包全名,这样就可以双击启动应用。
如执行上述打出来的jar的命令为:
java -jar heiheihei-springboot-1.0-SNAPSHOT.jar
学习目标:将Spring Boot项目使用maven指令打成jar包并运行测试
解析:
package
;java -jar 包名
在应用spring boot工程的时候;一般情况下都需要创建启动引导类Application.java和application.yml配置文件,而且内容都是一样的;为了便捷可以安装一个IDEA的插件 JBLSpringBootAppGen 在项目上右击之后可以自动生成启动引导类Application.java和application.yml配置文件。
Ctrl+Alt+S
)之后在插件选项中搜索SpringBoot,安装 JBLSpringBootAppGen
(可能存在热键冲突,无法通过快捷键进入,则File–>Setting–>Plugins) 当然需要重启idea
JBLSpringBootAppGen
即可 点击OK后会自动生成目录与yml文件转载地址:http://jnilf.baihongyu.com/