走进JavaWeb技术世界16:极简配置的SpringBoot

  1. 云栖社区>
  2. 博客>
  3. 正文

走进JavaWeb技术世界16:极简配置的SpringBoot

黄小斜 2017-09-15 17:21:17 浏览1121
展开阅读全文

一位阿里 Java 工程师的技术小站。作者黄小斜,专注 Java 相关技术:SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程,偶尔讲点Docker、ELK,同时也分享技术干货和学习经验,致力于Java全栈开发!(关注公众号后回复”Java“即可领取 Java基础、进阶、项目和架构师等免费学习资料,更有数据库、分布式、微服务等热门技术学习视频,内容丰富,兼顾原理和实践,另外也将赠送作者原创的Java学习指南、Java程序员面试指南等干货资源)

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的优缺点

优点

  1. 快速构建项目
  2. 对主流开发框架的无配置集成
  3. 项目可独立运行,无须外部依赖Servlet容器(Spring Boot默认自带了一个Tomcat)
  4. 提供运行时的应用监控
  5. 极大地提高了开发、部署效率
  6. 与云计算的天然集成

缺点

  1. 坑有些多, 文档略少

二、快速入门

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的高效和简洁了呢?配置就是如此简单,功能就是如此强大,但通过上面一系列的讲解,你是不是也产生一些疑惑呢,比如:

  1. Spring Boot的WEB应用默认端口就是8080,那这个端口要怎么修改呢?
  2. 为什么会出现"Cannot determine embedded database driver class for database type NONE"这样的错误?(或者说为什么springboot启动时会自动注入数据源和配置jpa)
  3. 为什么@SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})就可以解决"Cannot determine embedded database driver class for database type NONE"这样的错误呢?
  4. 既然Spring Boot的WEB应用默认使用的是自带的Tomcat,那要怎么部署到外部的Servlet容器呢?
  5. ...

不急,后续文章将会对这些问题一一解释清楚。

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详解系列文章: 

SpringBoot详解(一)快速入门 

SpringBoot详解(二)-Spring Boot的核心 

SpringBoot详解(三)-Spring Boot的web开发

一、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」 等关键字可以获取对应的免费学习资料。 


                     wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

网友评论

登录后评论
0/500
评论
黄小斜
+ 关注