走进JavaWeb技术世界16:极简配置的SpringBoot
SpringBoot详解(一)-快速入门
SpringBoot详解系列文章:
SpringBoot详解(一)-快速入门
SpringBoot详解(二)-Spring Boot的核心
SpringBoot详解(三)-Spring Boot的web开发
SpringBoot详解(四)-优雅地处理日志
一、Spring Boot
久闻Spring Boot大名,这两天终于得空,学习了一把,发觉Spring Boot确实好用,那Spring Boot到底是什么,又是怎么好用呢?
什么是Spring Boot
目前ssm框架还是比较常用的,其中的ss指的无非就是Spring 和 SpringMVC,我们可以简单的认为 "Spring Boot ≥ Spring + SpringMVC",没错,用了Spring Boot中涵盖了Spring和SpringMVC等大量常用开发配置,而且Spring Boot的配置极其简单,可以让你不用或者只需要很少的Spring配置就可以让你的项目快速运行起来。
Spring Boot的优缺点
优点
- 快速构建项目
- 对主流开发框架的无配置集成
- 项目可独立运行,无须外部依赖Servlet容器(Spring Boot默认自带了一个Tomcat)
- 提供运行时的应用监控
- 极大地提高了开发、部署效率
- 与云计算的天然集成
缺点
- 坑有些多, 文档略少
二、快速入门
1、Spring的Java配置方式
上面已经提到了,使用Spring Boot,可以让你不用或者只需要很少的Spring配置就可以让你的项目快速运行起来,说的就是使用代码注解来取代xml配置。其实从Spring3.x开始就已经提供了java配置方式,使用java配置方式可以更好的理解你配置的Bean,而如今的Spring4.x更是推荐java配置方式,java配置方式可以完全替代xml配置,下面就先来看看两个最基本的注释:
1)@Configuration 和 @Bean
Spring的java配置方式是通过@Configuration 和 @Bean这两个注释实现的:
- @Configuration 作用于类上,相当于一个xml配置文件
- @Bean 作用于方法上,相当于xml配置中的
2)小示例
该示例将通过java配置方式配置Spring,实现Spring IOC功能。
这是一个简单的模拟从数据库获取User数据的Dao类(注意,它并没有使用任何注解,也就是说UserDao目前并没有交给Spring容器管理)。
public class UserDao {
public List<String> queryUserList() {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
list.add("User " + i);
}
return list;
}
}
这是一个最最常见的Service,通过注入UserDao,使用UserDao的方法获取用户数据。
@Service
public class UserService {
@Autowired
UserDao userDao;
public void getUserList() {
List<String> list = userDao.queryUserList();
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
从这里开始就跟以往的Spring开发不一样了,这个类使用了2个新的注解,其中@Configuration表明该相当于Spring的一个xml配置文件,@Bean将一开始的UserDao配置给Spring管理.
@Configuration// 通过注解来表明该类是一个Spring的配置,相当于一个xml文件
public class SpringConfig {
@Bean// 这里要注意,方法名"getUserDao"将作为UserDao在容器中的id
public UserDao getUserDao() {
return new UserDao();
}
}
接下来就是获取Spring容器,从容器中拿到UserService,并调用其获取用户数据的方法,代码如下:
public class Test {
public static void main(String[] args) {
AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = (UserService) acac.getBean("userService");
userService.getUserList();
}
}
像普通的java程序一样,直接运行Test类中的main方法即可在控制台看到用户数据输出了。
细心的你应该发现了,以往获取Spring容器使用到的类要么是ClassPathXmlApplicationContext 或是 FileSystemXmlApplicationContext,但Spring Boot使用的却是AnnotationConfigApplicationContext,原因也好理解,因为我们Spring Boot使用的是java配置的方式,而以往使用的是Spring的xml配置方式.
2、第一个Web应用
通过上面的示例,我们已经知道了java配置方式是怎么回事了,那接下来便正式开始使用Spring Boot来开发我们的第一个web应用了.
1)pom.xml配置
设置spring boot的parent
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.2.RELEASE</version>
</parent>
说明:Spring boot的项目必须要将parent设置为spring boot的parent,该parent包含了大量默认的配置,大大简化了我们的开发。
导入spring boot的web支持
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
添加Spring boot的插件
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
通过上面简单的3步配置,Spring Boot就配置完毕了,相比以往的Spring、SpringMVC配置是不是要简洁的多呢?
2)小示例
@SpringBootApplication// Spring Boot项目的核心注解,主要目的是开启自动配置
@Controller//标明这是一个SpringMVC的Controller控制器
public class HelloApplication {
@RequestMapping("/hello")
@ResponseBody
public String hello() {
return "hello world";
}
// 在main方法中启动一个应用,即:这个应用的入口
public static void main(String[] args) {
SpringApplication.run(HelloApplication.class, args);
}
}
一般Spring Boot的Web应用都有一个xxxApplication类,并使用@SpringBootApplication注解标记,作为该web应用的加载入口。此外,还需要在main方法中(可以是任意一个类)使用SpringApplication.run(xxxApplication.class, args)来启动该web应用。
运行HelloApplication中的main()方法,启动该web应用后,在地址栏输入"http://localhost:8080/hello",就可以看到输出结果了。
3)运行报错
如果你项目中没有其他配置,那在运行这个简单的项目时一般是不会报错的,但如果很不幸你第一次运行就报错的话,也不用着急,大部分问题百度即可,本人在启动项目过程中遇到就"Cannot determine embedded database driver class for database type NONE"这样的错误,这样就记录一下,报错截图如下:
原因是:springboot启动时会自动注入数据源和配置jpa。
解决方法:在@SpringBootApplication中排除其注入
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})
所以,上面的代码修改如下即可:
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})
@Controller
public class HelloApplication {
...
}
三、疑问
到这里是不是已经大概感觉到了Spring Boot的高效和简洁了呢?配置就是如此简单,功能就是如此强大,但通过上面一系列的讲解,你是不是也产生一些疑惑呢,比如:
- Spring Boot的WEB应用默认端口就是8080,那这个端口要怎么修改呢?
- 为什么会出现"Cannot determine embedded database driver class for database type NONE"这样的错误?(或者说为什么springboot启动时会自动注入数据源和配置jpa)
- 为什么@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})就可以解决"Cannot determine embedded database driver class for database type NONE"这样的错误呢?
- 既然Spring Boot的WEB应用默认使用的是自带的Tomcat,那要怎么部署到外部的Servlet容器呢?
- ...
不急,后续文章将会对这些问题一一解释清楚。
SpringBoot详解(二)-Spring Boot的核心
SpringBoot详解系列文章:
SpringBoot详解(一)-快速入门
SpringBoot详解(二)-Spring Boot的核心
SpringBoot详解(三)-Spring Boot的web开发
SpringBoot详解(四)-优雅地处理日志
Spring Boot的核心
在上篇中我们成功运行了一个简单的web应用,其中有一个注解被轻易的带过了,但它在Spring Boot中是最重要的注解,没有之一,它就是@SpringBootApplication,本篇将对它与Spring Boot的配置进行深入的介绍。
1、@SpringBootApplication
前面已经说过了,一般Spring Boot的Web应用都有一个xxxApplication类,并使用@SpringBootApplication注解标记,作为该web应用的加载入口。那这个@SpringBootApplication注解到底是何方神圣?通过查看它的源码,可以发现它是一个组合注解:
@SpringBootApplication这个Spring Boot核心注解是由其它三个重要的注解组合,分别是: @SpringBootConfiguration 、 @EnableAutoConfiguration 和 @ComponentScan。
1)@SpringBootConfiguration
@SpringBootConfiguration是Spring Boot项目的配置注解,这也是一个组合注解。
通过上图代码,结合前面所讲的知识,不难猜测出@SpringBootConfiguration与@Configuration存在着某种关系,可以认为@SpringBootConfiguration就相当于@Configuration,在Spring Boot项目中推荐使用@SpringBootConfiguration替代@Configuration,不过因为注释长度问题,往往@Configuration较为常用。
2)@EnableAutoConfiguration
@EnableAutoConfiguration注解用于启用自动配置,该注解会使Spring Boot根据项目中依赖的jar包自动配置项目的配置项。
例如:上篇中,我们在编写第一个WEB应用时,就在pom.xml中引入了spring-boot-starter-web的依赖,所以项目中就会引入SpringMVC的依赖,就会自动配置tomcat和SpringMVC。
还有后面使用事务时,会引入spring-boot-starter-jdbc的依赖,让Spring Boot自动配置DataSourceTransactionManager或JpaTransactionManager,等等。。
3)@ComponentScan
@ComponentScan是组件扫描注解,不配置默认扫描@SpringBootApplication所在类的同级目录以及它的子目录(这很重要,后面很应用到这个特性)。当然你也可以自己指定要扫描的包目录,例如:
@ComponentScan(basePackages = "com.lqr.demo1")
2、取消部分自动配置
上面说了,Spring Boot根据项目中依赖的jar包自动配置项目的配置项,而Spring Boot支持的自动配置非常之多,如下图所示(只是其中的一部分):
当自动配置的东西一多了,就容易出问题,上篇中最后出现的"Cannot determine embedded database driver class for database type NONE"错误,就是因为springboot启动时会自动注入数据源和配置jpa,所以我们就需要取消Spring Boot的部分自动配置。至于取消自动配置的方式也相当简单,就是对@SpringBootApplication注解的exclude进行赋值即可,如:
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})
@Controller
public class HelloApplication {
...
}
其他的取消自动配置以此类推。
3、自定义Banner
这个知识点其实对开发意义不太,但不妨了解下(可以装个逼~~)。在Spring Boot项目启动时,控制台会输出一个"spring>>>"的banner文字图案,如:
这个banner是可以自定义的,自定义的方法很简单:只需要把想输出的文字保存在banner.txt文件中,然后把这个banner.txt放到resources目录下即可:
运行项目,然后控制台就可以输出banner.txt中的文字了。
Text to ASCII Art Generator (TAAG)这个网站可以得到文字图案。
4、Starter pom
Spring Boot为我们提供了简化企业级开发绝大多数场景的start pom(类似于组件),只要使用了对应的starter pom,Spring Boot就会为我们提供自动配置的Bean。
这里官方给出的starter,以下是"好心人"对这些Starter pom做的翻译:
怎么使用?直接在pom.xml中引入依赖即可(不懂请参考上篇中“第一个Web应用”中pom.xml配置的第二部分,或请自行百度)。
5、使用Xml配置文件
常规开发中,java配置方式已经可以完全取代xml配置方式了,但有时我们并不想使用java配置,而是继续沿用之前的xml配置方式,或者出于其他原因,一定要在xml中进行配置,那该怎么办呢,很简单,使用@ImportResource注解即可:
@ImportResource(value = {"classpath:xxx1.xml","classpath:xxx2.xml"})
6、全局配置文件
Spring Boot项目使用一个全局的配置文件application.properties或者是application.yml,在resources目录下或者类路径下的/config下,一般我们放到resources下。
我们知道Spring Boot会根据在pom.xml中依赖的jar包进行自动配置,当我们要对这些jar包对应的框架进行配置又该怎么办呢,没错,可以在全局配置文件(application.properties或者是application.yml)中进行配置,如tomcat的端口配置等。
1)全局配置文件的基本使用(application.properties)
这部分使用application.properties中的书写方式来介绍。
①tomcat端口配置
server.port=8888
②修改Spring MVC拦截路径规则
默认Spring MVC拦截路径规则是/,如果要修改成*.html的话,可以在全局配置文件中进行如下设置:
server.servlet-path=*.html
③视图解析器配置
一样的,Spring Boot也可以通过全局配置文件对视图解析器进行配置:
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
④日志输出
Spring Boot对各种日志框架都做了支持,我们可以通过配置来修改默认的日志的配置:
#设置日志级别
logging.level.org.springframework=DEBUG
2)全局配置文件的进阶使用(application.yml)
这部分使用application.yml中的书写方式来介绍。
properties与yml文件在形式上有所差别,yml文件的书写方式比较简洁,类似eclipse中package的flag呈现方式(而properties文件则像Hierarchical方式)。如上面properties文件中的属性配置使用yml文件来写:
server:
port: 8080
context-path: /
spring:
mvc:
view:
prefix: /WEB-INF/views/
suffix: .jsp
logging:
level: debug
yml文件在书写时,需要注意一个地方:冒号与值中间是存在空格的!
①自定义属性
全局配置文件并不只是配置Spring Boot中已经存在的属性,我们也可以自定义属性(别忘了,它本身就是一个properties文件),代码需要使用@Value("${xxx}")注解来获取这些属性,如:
②属性引用属性
属性引用属性也简单,使用${xxx}就可以引用配置文件中的属性了。
lqr: 666
content: "${lqr} is six six six"
③属性转对象
这个就比较有看点了,以上面的"server.port: 8080"为例,我们可以认为是Server这个类中有一个port属性,其值为8080。可以使用@ConfigurationProperties(prefix = "属性名前缀")这个注解作为配置文件中属性转对象属性的桥梁,具体如图所示:
Spring Boot的全局配置很强大,同时它可以配置的属性也很多,以上只列出几个常用的属性配置,如需查看完整的全局属性配置,请到spring-boot官方配置文档查看。好了,本篇到此结束,主要介绍了Spring Boot中几个核心注解与自动配置,同时解决上篇中的几个问题,从下篇开始,将针对Spring Boot的web开发进行介绍。
SpringBoot详解(三)-Spring Boot的web开发
SpringBoot详解系列文章:
一、web基础配置
1、访问静态资源
1)进入规则为 / 时
如果进入SpringMVC的规则为/时,Spring Boot的默认静态资源的路径为:
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/
也就是说,在默认的Spring MVC进入规则下,classpath下的META-INF/resources目录、resources目录、static目录和public目录中的静态资料是可以直接通过 "http: // xxx.com/静态资源" 的方式访问到的。如:
2)进入规则为*.xxx 或者 不指定静态文件路径时
如果进入SpringMVC的规则为*.xxx时(如:*.html),则上述目录下的静态资源将无法直接访问,需要将静态资源放置到webapp下的static目录中即可通过 "http://xxx.com/static/静态资源" 访问。此外,默认不配置SpringMVC的规则下也可以如此访问,也就是说这种访问静态资源的方式是通用的。如图所示:
2、自定义拦截器
增加一个拦截器,需要通过继承WebMvcConfigurerAdapter然后重写父类中的方法进行扩展。
@Configuration
public class MySpringMvcConfig extends WebMvcConfigurerAdapter {
@Override
public void addInterceptors(InterceptorRegistry registry) {
HandlerInterceptor handlerInterceptor = new HandlerInterceptor() {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
System.out.println("自定义拦截器。。。");
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
};
// 添加拦截器并设置拦截规则
registry.addInterceptor(handlerInterceptor).addPathPatterns("/**");
}
}
3、自定义消息转化器
自定义消息转化器有两种实现方式,一种是@Bean方式,另一种是自定义拦截器。
1)@Bean方式
只需要在@Configuration的类中添加消息转化器的@bean加入到Spring容器,就会被Spring Boot自动加入到容器中。
// spring boot默认就有消息转化器,其编码格式为utf-8
@Bean
public StringHttpMessageConverter stringHttpMessageConverter() {
StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
return stringHttpMessageConverter;
}
2)自定义拦截器方式
WebMvcConfigurerAdapter的功能很强大,除了可以配置拦截器外,还可以配置消息转换器。
@Configuration
public class MySpringMvcConfig extends WebMvcConfigurerAdapter {
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
converters.add(stringHttpMessageConverter);
}
}
4、读取外部的配置文件
@Configuration
@PropertySource(value = { "classpath:jdbc.properties", "classpath:base.properties" }, ignoreResourceNotFound = true)
public class 任意类 {
}
5、Druid DataSource的配置
Druid提供了一个高效、功能强大、可扩展性好的数据库连接池,常用于替换DBCP和C3P0。但在Spring Boot上配置比较“恶心”,这里就简单的贴出个人参照网上的配置代码,不必深究。
1)引入依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.11</version>
</dependency>
2)jdbc.properties
项目中一般会创建一个jdbc.properties文件来记录数据库的连接信息。
#MySQL
jdbc.url=jdbc:mysql://127.0.0.1:3306/dbxxx?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456
#Druid
jdbc.initialSize=0
jdbc.minIdle=0
jdbc.maxActive=150
3)配置Druid数据源
建议将配置Druid数据源的操作放在@SpringBootApplication注解的类中。
@SpringBootApplication
@Configuration
@PropertySource(value = {"classpath:jdbc.properties"})
public class MyWebApplication{
@Value("${jdbc.url}")
public String jdbcUrl;
@Value("${jdbc.username}")
public String jdbcUsername;
@Value("${jdbc.password}")
public String jdbcPassword;
@Value("${jdbc.initialSize}")
public int jdbcInitialSize;
@Value("${jdbc.minIdle}")
public int jdbcMinIdle;
@Value("${jdbc.maxActive}")
public int jdbcMaxActive;
@Bean
public ServletRegistrationBean druidServletRegistrationBean() {
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
servletRegistrationBean.setServlet(new StatViewServlet());
servletRegistrationBean.addUrlMappings("/druid/*");
return servletRegistrationBean;
}
@Bean
public FilterRegistrationBean duridFilterRegistrationBean() {
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
filterRegistrationBean.setFilter(new WebStatFilter());
HashMap<String, String> initParams = new HashMap<>();
// 设置忽略请求
initParams.put("exclusions", "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*");
filterRegistrationBean.setInitParameters(initParams);
filterRegistrationBean.addUrlPatterns("/*");
return filterRegistrationBean;
}
@Bean(initMethod = "init", destroyMethod = "close")
public DruidDataSource druidDataSource() {
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setUrl(jdbcUrl);
druidDataSource.setUsername(jdbcUsername);
druidDataSource.setPassword(jdbcPassword);
druidDataSource.setInitialSize(jdbcInitialSize);
druidDataSource.setMinIdle(jdbcMinIdle);
druidDataSource.setMaxActive(jdbcMaxActive);
return druidDataSource;
}
}
之后就可以通过@AutoWried注解得到数据源(druidDataSource)了。
6、数据库框架集成
1)jpa集成
Jpa在使用上跟Hibernate很像,因为它们之前的关系非同一般,有兴趣可以看看《Hibernate与Jpa的关系,终于弄懂》这篇文章。Spring Boot对jpa的支持也是很好的,配置起来非常简单。
在pom.xml中引用jpa及数据库驱动(如:mysql)依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
在application.yml文件中配置
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1/dbgirl
username: root
password: 123456
jpa:
hibernate:
ddl-auto: update #第一次加载hibernate时根据model类会自动建立起表的结构(前提是先建立好数据库),以后加载hibernate时根据 model类自动更新表结构,即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后,表结构是不会被马上建立起来的,是要等 应用第一次运行起来后才会。
show-sql: true
2)MyBatis集成
Mybatis和Spring Boot的整合有两种方式:
第一种:使用mybatis官方提供的Spring Boot整合包实现,地址:spring-boot-starter
第二种:使用mybatis-spring整合的方式,也就是我们传统的方式
这里推荐并使用第二种方式,因为可以很方便的控制Mybatis的各种配置。这里假设你已经配置过数据源了(数据源可以是druid、dbcp、c3p0...)。
首先,需要在pom.xml文件中引用mybatis依赖
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.2</version>
</dependency>
然后,创建一个Mybatis的配置类:
@Configuration
public class MybatisConfig {
@Autowired
DruidDataSource druidDataSource;
@Bean
@ConditionalOnMissingBean// 当Spring容器中没有SqlSessionFactoryBean时才创建
public SqlSessionFactoryBean sqlSessionFactoryBean() {
SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
// 设置数据源
sqlSessionFactory.setDataSource(druidDataSource);
// 设置别名扫描包
sqlSessionFactory.setTypeAliasesPackage("com.lqr.demo3.bean");
// 设置Mybatis的配置文件位置
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Resource mybatisConfigXml = resolver.getResource("classpath:mybatis-config.xml");
sqlSessionFactory.setConfigLocation(mybatisConfigXml);
return sqlSessionFactory;
}
}
最后,创建Mapper接口的扫描类MapperScannerConfig:
@Configuration
@AutoConfigureAfter(MybatisConfig.class)// Mybatis的扫描配置必须在SqlSessionFactory被创建之后
public class MapperScanConfig {
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
mapperScannerConfigurer.setBasePackage("com.lqr.demo3.mapper");
return mapperScannerConfigurer;
}
}
7、设置事务管理
Spring Boot中推荐使用@Transactional注解来申明事务。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
当引入jdbc依赖之后,Spring Boot会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager,所以我们不需要任何额外配置就可以用@Transactional注解进行事务的使用。
@Service
@Transactional
public class GirlService {
@Transactional
public void insertGirl() {
Girl girlA = new Girl();
girlA.setCupSize("A");
girlA.setAge(18);
girlRespository.save(girlA);
}
}
@Transactional不仅可以注解在方法,也可以注解在类上。当注解在类上时,意味着此类所有public方法都会开启事务。如果类级别和方法级别同时使用了@Transactional注解,则使用在类级别的注解会重载方法级别的注解。
8、开启jsp支持
Spring boot默认内嵌的tomcat是不支持jsp页面的,如果项目中使用到了jsp,需要导入如下依赖才能正常访问。
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
二、Web编码进阶
这部分可能跟Spring Boot的关系并不是很大(或者说,并非Spring Boot特有),但很值得我们在编码方面作为参考。
1、Spring MVC中新的注解
1)@RestController
现在的Web项目已经越来越趋向于将后端与前端分别开发了,如果贵公司的项目就是使用json来进行前后端交互,且使用Spring MVC来开发的话,就一定会用到下面这2个注解:
@Controller
@ResponseBody
public class GirlController {
...
}
而在Spring MVC4之后,我们可以使用@RestController 注解来开发基于Spring MVC4的REST风格的JSON服务。
通俗的说就是@RestController = @Controller + @ResponseBody。
@Controller和@RestController的区别:
如果只是使用@RestController注解Controller,则Controller中的方法无法返回jsp页面,配置的视图解析器InternalResourceViewResolver不起作用,返回的内容就是Return 里的内容。 例如:本来应该到success.jsp页面的,则其显示success.
2)http组合注解
Spring4.3中引进了{@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping},来帮助简化常用的HTTP方法的映射,并更好地表达被注解方法的语义。
@GetMapping =>
@RequestMapping(value = "/xxx",method = RequestMethod.GET)
@PostMapping =>
@RequestMapping(value = "/xxx",method = RequestMethod.POST)
@PutMapping =>
@RequestMapping(value = "/xxx",method = RequestMethod.PUT)
@DeleteMapping =>
@RequestMapping(value = "/xxx",method = RequestMethod.DELETE)
...
2、数据校验
Web开发中,对从前端传过来的数据做数据校验已经是家常便饭的事了,但如果校验的数据很多,那么,一方面在开发上就需要做很多if判断,另一方面则是代码上显得不再简洁。其实,使用@Valid + BindingResult就可以优雅地解决这样的问题。使用示例如下:
1)@Valid + BindingResult
首先,使用一个Java Bean来接收前端提交的数据。在这个Java Bean之前加上@Valid,在这个Java Bean之后加上BindingResult(BindingResult参数必须紧跟在@Valid参数之后。)
/**
* 添加一个女生
*/
@PostMapping(value = "/girls")
public Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult) {
if (bindingResult.hasErrors()) {
return ResultUtils.error(-1, bindingResult.getFieldError().getDefaultMessage());
}
return ResultUtils.success(girlRespository.save(girl));
}
2)设置校验规则
然后,需要在@Valid注解的Java Bean中,使用各种"规则注解"对其中的属性进行校验规则的设定。示例如下:
public class Girl {
private Integer id;
@NotBlank(message = "这个字段必传")
private String cupSize;
@Min(value = 18, message = "未成年少女禁止入内")
private Integer age;
@NotNull(message = "金额必传")
private Double money;
...
}
示例中,"规则注解"的message值可以在Controller中通过bindingResult.getFieldError().getDefaultMessage()获取。
这类用于数据校验的注解还有很多,有兴趣的可以好好研究一下:
注解 | 类型 | 说明 |
---|---|---|
@AssertFalse | Boolean,boolean | 验证注解的元素值是false |
@AssertTrue | Boolean,boolean | 验证注解的元素值是true |
@NotNull | 任意类型 | 验证注解的元素值不是null |
@Null | 任意类型 | 验证注解的元素值是null |
@Min(value=值) | BigDecimal,BigInteger, byte,short, int, long,等任何Number或CharSequence(存储的是数字)子类型 | 验证注解的元素值大于等于@Min指定的value值 |
@Max(value=值) | 和@Min要求一样 | 验证注解的元素值小于等于@Max指定的value值 |
@DecimalMin(value=值) | 和@Min要求一样 | 验证注解的元素值大于等于@ DecimalMin指定的value值 |
@DecimalMax(value=值) | 和@Min要求一样 | 验证注解的元素值小于等于@ DecimalMax指定的value值 |
@Digits(integer=整数位数, fraction=小数位数) | 和@Min要求一样 | 验证注解的元素值的整数位数和小数位数上限 |
@Size(min=下限, max=上限) | 字符串、Collection、Map、数组等 | 验证注解的元素值的在min和max(包含)指定区间之内,如字符长度、集合大小 |
@Past | java.util.Date,java.util.Calendar;Joda Time类库的日期类型 | 验证注解的元素值(日期类型)比当前时间早 |
@Future | 与@Past要求一样 | 验证注解的元素值(日期类型)比当前时间晚 |
@NotBlank | CharSequence子类型 | 验证注解的元素值不为空(不为null、去除首位空格后长度为0),不同于@NotEmpty,@NotBlank只应用于字符串且在比较时会去除字符串的首位空格 |
@Length(min=下限, max=上限) | CharSequence子类型 | 验证注解的元素值长度在min和max区间内 |
@NotEmpty | CharSequence子类型、Collection、Map、数组 | 验证注解的元素值不为null且不为空(字符串长度不为0、集合大小不为0) |
@Range(min=最小值, max=最大值) | BigDecimal,BigInteger,CharSequence, byte, short, int, long等原子类型和包装类型 | 验证注解的元素值在最小值和最大值之间 |
@Email(regexp=正则表达式,flag=标志的模式) | CharSequence子类型(如String) | 验证注解的元素值是Email,也可以通过regexp和flag指定自定义的email格式 |
@Pattern(regexp=正则表达式,flag=标志的模式) | String,任何CharSequence的子类型 | 验证注解的元素值与指定的正则表达式匹配 |
@Valid | 任何非原子类型 | 指定递归验证关联的对象;如用户对象中有个地址对象属性,如果想在验证用户对象时一起验证地址对象的话,在地址对象上加@Valid注解即可级联验证 |
3、面积切面编程(AOP配置)
AOP是Spring中一大核心,若在SpringBoot中要使用AOP只需两步:
1)引入AOP的starter依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2)编写切面类
@Aspect
@Component
public class HttpAspect {
private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
@Pointcut("execution(public * com.lqr.controller.GirlController.*(..))")
public void log() {
}
@Before("log()")
public void deBefore(JoinPoint joinPoint) {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// url
logger.info("url={}", request.getRequestURL());
// method
logger.info("method={}", request.getMethod());
// ip
logger.info("ip={}", request.getRemoteAddr());
// 类方法
logger.info("class_method={}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
// 参数
logger.info("args={}", joinPoint.getArgs());
}
@After("log()")
public void doAfter() {
logger.info("doAfter...");
}
@AfterReturning(returning = "object", pointcut = "log()")
public void doAfterReturning(Object object) {
if (object != null)
logger.info("response={}", object.toString());
}
}
4、统一异常处理(配置通知Advice)
1)自定义异常
这里之所以继承RuntimeException,是为了方便事务回滚。而自定义异常的好处在于:一方面可以使代码语义化,另一方面使得我们编码更加方便。
public class GirlException extends RuntimeException {
private Integer code;
public GirlException(ResultEnum resultEnum) {
super(resultEnum.getMsg());
this.code = resultEnum.getCode();
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
}
2)配置全局异常捕获器
使用全局异常捕获器,一方面可以捕获到整个项目中的Exception及其子类(包含RuntimeException等),另一方面可以对异常进行统一处理并返回统一的数据格式,为前端提供友好的数据交互。
@ControllerAdvice
public class ExceptionHandle {
private final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);
@ExceptionHandler(value = Exception.class)
@ResponseBody
public Result handle(Exception e) {
if (e instanceof GirlException) {
GirlException girlException = (GirlException) e;
return ResultUtils.error(girlException.getCode(), girlException.getMessage());
} else {
logger.error("【系统异常】{}", e);
return ResultUtils.error(-1, "未知错误");
}
}
}
三、开发与生产
1、热部署
Web开发中,没有热部署怎么能行呢?所以,下面就介绍下Spring Boot的热部署配置。
1)在pom.xml中配置热部署需要的依赖与插件
<dependencies>
...
<!--spring boot 热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<!--spring boot 热部署-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
</plugins>
...
</build>
2)开启自动编译
打开Idea的Settings界面,找到"Build,Execution,Depolyment",在Compiler中将"Build project automatically"打钩。
3)修改pom.xml的维护(Maintenance)登记项
使用快捷键 "ctrl+shift+alt+/" 打开pom.xml的维护(Maintenance)菜单,找到登记(registry)项,单击打开。
4)允许应用程序运行时自动编译
在登记(registry)中找到"compiler.automake.allow.when.app.running"这一项打钩,关闭。最后重启项目即可!!!
2、发布到独立的tomcat中运行
尽管Spring Boot项目会内置一个tomcat,仅只需通过一个简单的指令便可启动项目,但在生产环境下,我们还是习惯将项目发布到第三外的servlet容器中,下面将介绍如果将一个Spring Boot项目团部署到第三方tomcat中运行。
1)修改工程的打包方式为war
2)将spring-boot-starter-tomcat的范围设置为provided
spring-boot-starter-tomcat是Spring Boot默认就会配置的,即上面说到的内嵌tomcat,将其设置为provided是在打包时会将该包(依赖)排除,因为要放到独立的tomcat中运行,Spring Boot内嵌的Tomcat是不需要用到的。
<!--spring boot tomcat(默认可以不用配置,但当需要把当前web应用布置到外部servlet容器时就需要配置,并将scope配置为provided)-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
3)修改代码,设置启动配置
需要继承SpringBootServletInitializer,并重写configure()方法,将Spring Boot的入口类设置进去。
// 若要部署到外部servlet容器,需要继承SpringBootServletInitializer并重写configure()
@SpringBootApplication
@Configuration
public class MyWebApplication extends SpringBootServletInitializer
{
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
// 设置启动类,用于独立tomcat运行的入口
return builder.sources(MyWebApplication.class);
}
}
4)打war包并部署到tomcat
微信公众号【黄小斜】大厂程序员,互联网行业新知,终身学习践行者。关注后回复「Java」、「Python」、「C++」、「大数据」、「机器学习」、「算法」、「AI」、「Android」、「前端」、「iOS」、「考研」、「BAT」、「校招」、「笔试」、「面试」、「面经」、「计算机基础」、「LeetCode」 等关键字可以获取对应的免费学习资料。