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

最新推荐文章于 2024-01-27 23:40:22 发布
最新推荐文章于 2024-01-27 23:40:22 发布
阅读量274 收藏
点赞数
分类专栏： javaWeb
原文链接：https://mp.csdn.net/editor/html/116898358
版权

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容器管理）。

  1.  

    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的插件

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

​​​​​​​​​​​​​​

 

通过上面简单的3步配置,Spring Boot就配置完毕了,相比以往的Spring、SpringMVC配置是不是要简洁的多呢？

2）小示例

 

  1. @SpringBootApplication// Spring Boot项目的核心注解，主要目的是开启自动配置

  2. @Controller//标明这是一个SpringMVC的Controller控制器

  3. public class HelloApplication {

  4.  

  5. @RequestMapping("/hello")

  6. @ResponseBody

  7. public String hello() {

  8. return "hello world";

  9. }

  10.  

  11. // 在main方法中启动一个应用，即：这个应用的入口

  12. public static void main(String[] args) {

  13. SpringApplication.run(HelloApplication.class, args);

  14. }

  15.  

  16. }

一般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})

所以，上面的代码修改如下即可：

 

  1. @SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})

  2. @Controller

  3. public class HelloApplication {

  4. ...

  5. }

三、疑问

到这里是不是已经大概感觉到了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进行赋值即可，如：

 

  1. @SpringBootApplication(exclude={DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class})

  2. @Controller

  3. public class HelloApplication {

  4. ...

  5. }

其他的取消自动配置以此类推。

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也可以通过全局配置文件对视图解析器进行配置：

 

  1. spring.mvc.view.prefix=/WEB-INF/views/

  2. spring.mvc.view.suffix=.jsp

④日志输出

Spring Boot对各种日志框架都做了支持，我们可以通过配置来修改默认的日志的配置：

 

  1. #设置日志级别

  2. logging.level.org.springframework=DEBUG

2）全局配置文件的进阶使用（application.yml）

这部分使用application.yml中的书写方式来介绍。

properties与yml文件在形式上有所差别，yml文件的书写方式比较简洁，类似eclipse中package的flag呈现方式（而properties文件则像Hierarchical方式）。如上面properties文件中的属性配置使用yml文件来写：

 

  1. server:

  2. port: 8080

  3. context-path: /

  4.  

  5. spring:

  6. mvc:

  7. view:

  8. prefix: /WEB-INF/views/

  9. suffix: .jsp

  10.  

  11. logging:

  12. level: debug

yml文件在书写时，需要注意一个地方：冒号与值中间是存在空格的！

①自定义属性

全局配置文件并不只是配置Spring Boot中已经存在的属性，我们也可以自定义属性（别忘了，它本身就是一个properties文件），代码需要使用@Value("${xxx}")注解来获取这些属性，如：

 

 

②属性引用属性

属性引用属性也简单，使用${xxx}就可以引用配置文件中的属性了。

 

  1. lqr: 666

  2. 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然后重写父类中的方法进行扩展。

 

  1. @Configuration

  2. public class MySpringMvcConfig extends WebMvcConfigurerAdapter {

  3.  

  4. @Override

  5. public void addInterceptors(InterceptorRegistry registry) {

  6. HandlerInterceptor handlerInterceptor = new HandlerInterceptor() {

  7. @Override

  8. public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {

  9. System.out.println("自定义拦截器。。。");

  10. return true;

  11. }

  12.  

  13. @Override

  14. public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

  15.  

  16. }

  17.  

  18. @Override

  19. public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

  20.  

  21. }

  22. };

  23. // 添加拦截器并设置拦截规则

  24. registry.addInterceptor(handlerInterceptor).addPathPatterns("/**");

  25. }

  26. }

3、自定义消息转化器

自定义消息转化器有两种实现方式，一种是@Bean方式，另一种是自定义拦截器。

1）@Bean方式

只需要在@Configuration的类中添加消息转化器的@bean加入到Spring容器，就会被Spring Boot自动加入到容器中。

 

  1. // spring boot默认就有消息转化器，其编码格式为utf-8

  2. @Bean

  3. public StringHttpMessageConverter stringHttpMessageConverter() {

  4. StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));

  5. return stringHttpMessageConverter;

  6. }

2）自定义拦截器方式

WebMvcConfigurerAdapter的功能很强大，除了可以配置拦截器外，还可以配置消息转换器。

 

  1. @Configuration

  2. public class MySpringMvcConfig extends WebMvcConfigurerAdapter {

  3.  

  4. @Override

  5. public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {

  6. StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));

  7. converters.add(stringHttpMessageConverter);

  8. }

  9. }

4、读取外部的配置文件

 

  1. @Configuration

  2. @PropertySource(value = { "classpath:jdbc.properties", "classpath:base.properties" }, ignoreResourceNotFound = true)

  3. public class 任意类 {

  4.  

  5. }

5、Druid DataSource的配置

Druid提供了一个高效、功能强大、可扩展性好的数据库连接池，常用于替换DBCP和C3P0。但在Spring Boot上配置比较“恶心”，这里就简单的贴出个人参照网上的配置代码，不必深究。

1）引入依赖

 

  1. <dependency>

  2. <groupId>com.alibaba</groupId>

  3. <artifactId>druid</artifactId>

  4. <version>1.0.11</version>

  5. </dependency>

2）jdbc.properties

项目中一般会创建一个jdbc.properties文件来记录数据库的连接信息。

 

  1. #MySQL

  2. jdbc.url=jdbc:mysql://127.0.0.1:3306/dbxxx?useUnicode=true&characterEncoding=utf-8

  3. jdbc.username=root

  4. jdbc.password=123456

  5. #Druid

  6. jdbc.initialSize=0

  7. jdbc.minIdle=0

  8. jdbc.maxActive=150

3）配置Druid数据源

建议将配置Druid数据源的操作放在@SpringBootApplication注解的类中。

 

  1. @SpringBootApplication

  2. @Configuration

  3. @PropertySource(value = {"classpath:jdbc.properties"})

  4. public class MyWebApplication{

  5.  

  6. @Value("${jdbc.url}")

  7. public String jdbcUrl;

  8. @Value("${jdbc.username}")

  9. public String jdbcUsername;

  10. @Value("${jdbc.password}")

  11. public String jdbcPassword;

  12. @Value("${jdbc.initialSize}")

  13. public int jdbcInitialSize;

  14. @Value("${jdbc.minIdle}")

  15. public int jdbcMinIdle;

  16. @Value("${jdbc.maxActive}")

  17. public int jdbcMaxActive;

  18.  

  19. @Bean

  20. public ServletRegistrationBean druidServletRegistrationBean() {

  21. ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();

  22. servletRegistrationBean.setServlet(new StatViewServlet());

  23. servletRegistrationBean.addUrlMappings("/druid/*");

  24. return servletRegistrationBean;

  25. }

  26.  

  27. @Bean

  28. public FilterRegistrationBean duridFilterRegistrationBean() {

  29. FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

  30. filterRegistrationBean.setFilter(new WebStatFilter());

  31. HashMap<String, String> initParams = new HashMap<>();

  32. // 设置忽略请求

  33. initParams.put("exclusions", "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*");

  34. filterRegistrationBean.setInitParameters(initParams);

  35. filterRegistrationBean.addUrlPatterns("/*");

  36. return filterRegistrationBean;

  37. }

  38.  

  39. @Bean(initMethod = "init", destroyMethod = "close")

  40. public DruidDataSource druidDataSource() {

  41. DruidDataSource druidDataSource = new DruidDataSource();

  42. druidDataSource.setUrl(jdbcUrl);

  43. druidDataSource.setUsername(jdbcUsername);

  44. druidDataSource.setPassword(jdbcPassword);

  45. druidDataSource.setInitialSize(jdbcInitialSize);

  46. druidDataSource.setMinIdle(jdbcMinIdle);

  47. druidDataSource.setMaxActive(jdbcMaxActive);

  48. return druidDataSource;

  49. }

  50. }

之后就可以通过@AutoWried注解得到数据源(druidDataSource)了。

6、数据库框架集成

1）jpa集成

Jpa在使用上跟Hibernate很像，因为它们之前的关系非同一般，有兴趣可以看看《Hibernate与Jpa的关系，终于弄懂》这篇文章。Spring Boot对jpa的支持也是很好的，配置起来非常简单。

在pom.xml中引用jpa及数据库驱动（如：mysql）依赖

 

  1. <dependency>

  2. <groupId>org.springframework.boot</groupId>

  3. <artifactId>spring-boot-starter-data-jpa</artifactId>

  4. </dependency>

  5. <dependency>

  6. <groupId>mysql</groupId>

  7. <artifactId>mysql-connector-java</artifactId>

  8. </dependency>

在application.yml文件中配置

 

  1. spring:

  2. datasource:

  3. driver-class-name: com.mysql.jdbc.Driver

  4. url: jdbc:mysql://127.0.0.1/dbgirl

  5. username: root

  6. password: 123456

  7. jpa:

  8. hibernate:

  9. ddl-auto: update #第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等 应用第一次运行起来后才会。

  10. show-sql: true

2）MyBatis集成

Mybatis和Spring Boot的整合有两种方式：

第一种：使用mybatis官方提供的Spring Boot整合包实现，地址：spring-boot-starter

第二种：使用mybatis-spring整合的方式，也就是我们传统的方式

这里推荐并使用第二种方式，因为可以很方便的控制Mybatis的各种配置。这里假设你已经配置过数据源了（数据源可以是druid、dbcp、c3p0...）。

首先，需要在pom.xml文件中引用mybatis依赖

 

  1. <dependency>

  2. <groupId>org.mybatis</groupId>

  3. <artifactId>mybatis</artifactId>

  4. <version>3.3.0</version>

  5. </dependency>

  6. <dependency>

  7. <groupId>org.mybatis</groupId>

  8. <artifactId>mybatis-spring</artifactId>

  9. <version>1.2.2</version>

  10. </dependency>

然后，创建一个Mybatis的配置类：

 

  1. @Configuration

  2. public class MybatisConfig {

  3.  

  4. @Autowired

  5. DruidDataSource druidDataSource;

  6.  

  7. @Bean

  8. @ConditionalOnMissingBean// 当Spring容器中没有SqlSessionFactoryBean时才创建

  9. public SqlSessionFactoryBean sqlSessionFactoryBean() {

  10. SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();

  11. // 设置数据源

  12. sqlSessionFactory.setDataSource(druidDataSource);

  13. // 设置别名扫描包

  14. sqlSessionFactory.setTypeAliasesPackage("com.lqr.demo3.bean");

  15. // 设置Mybatis的配置文件位置

  16. PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

  17. Resource mybatisConfigXml = resolver.getResource("classpath:mybatis-config.xml");

  18. sqlSessionFactory.setConfigLocation(mybatisConfigXml);

  19. return sqlSessionFactory;

  20. }

  21.  

  22. }

最后，创建Mapper接口的扫描类MapperScannerConfig：

 

  1. @Configuration

  2. @AutoConfigureAfter(MybatisConfig.class)// Mybatis的扫描配置必须在SqlSessionFactory被创建之后

  3. public class MapperScanConfig {

  4.  

  5. @Bean

  6. public MapperScannerConfigurer mapperScannerConfigurer() {

  7. MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();

  8. mapperScannerConfigurer.setBasePackage("com.lqr.demo3.mapper");

  9. return mapperScannerConfigurer;

  10. }

  11.  

  12. }

7、设置事务管理

Spring Boot中推荐使用@Transactional注解来申明事务。

 

  1. <dependency>

  2. <groupId>org.springframework.boot</groupId>

  3. <artifactId>spring-boot-starter-jdbc</artifactId>

  4. </dependency>

当引入jdbc依赖之后，Spring Boot会自动默认分别注入DataSourceTransactionManager或JpaTransactionManager，所以我们不需要任何额外配置就可以用@Transactional注解进行事务的使用。

 

  1. @Service

  2. @Transactional

  3. public class GirlService {

  4.  

  5. @Transactional

  6. public void insertGirl() {

  7. Girl girlA = new Girl();

  8. girlA.setCupSize("A");

  9. girlA.setAge(18);

  10. girlRespository.save(girlA);

  11. }

  12. }

@Transactional不仅可以注解在方法，也可以注解在类上。当注解在类上时，意味着此类所有public方法都会开启事务。如果类级别和方法级别同时使用了@Transactional注解，则使用在类级别的注解会重载方法级别的注解。

8、开启jsp支持

Spring boot默认内嵌的tomcat是不支持jsp页面的，如果项目中使用到了jsp，需要导入如下依赖才能正常访问。

 

  1. <dependency>

  2. <groupId>org.apache.tomcat.embed</groupId>

  3. <artifactId>tomcat-embed-jasper</artifactId>

  4. <scope>provided</scope>

  5. </dependency>

二、Web编码进阶

这部分可能跟Spring Boot的关系并不是很大（或者说，并非Spring Boot特有），但很值得我们在编码方面作为参考。

1、Spring MVC中新的注解

1）@RestController

现在的Web项目已经越来越趋向于将后端与前端分别开发了，如果贵公司的项目就是使用json来进行前后端交互，且使用Spring MVC来开发的话，就一定会用到下面这2个注解：

 

  1. @Controller

  2. @ResponseBody

  3. public class GirlController {

  4. ...

  5. }

而在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方法的映射，并更好地表达被注解方法的语义。

 

  1. @GetMapping =>

  2. @RequestMapping(value = "/xxx",method = RequestMethod.GET)

  3. @PostMapping =>

  4. @RequestMapping(value = "/xxx",method = RequestMethod.POST)

  5. @PutMapping =>

  6. @RequestMapping(value = "/xxx",method = RequestMethod.PUT)

  7. @DeleteMapping =>

  8. @RequestMapping(value = "/xxx",method = RequestMethod.DELETE)

  9. ...

2、数据校验

Web开发中，对从前端传过来的数据做数据校验已经是家常便饭的事了，但如果校验的数据很多，那么，一方面在开发上就需要做很多if判断，另一方面则是代码上显得不再简洁。其实，使用@Valid + BindingResult就可以优雅地解决这样的问题。使用示例如下：

1）@Valid + BindingResult

首先，使用一个Java Bean来接收前端提交的数据。在这个Java Bean之前加上@Valid，在这个Java Bean之后加上BindingResult（BindingResult参数必须紧跟在@Valid参数之后。）

 

  1. /**

  2. * 添加一个女生

  3. */

  4. @PostMapping(value = "/girls")

  5. public Result<Girl> girlAdd(@Valid Girl girl, BindingResult bindingResult) {

  6. if (bindingResult.hasErrors()) {

  7. return ResultUtils.error(-1, bindingResult.getFieldError().getDefaultMessage());

  8. }

  9. return ResultUtils.success(girlRespository.save(girl));

  10. }

2）设置校验规则

然后，需要在@Valid注解的Java Bean中，使用各种"规则注解"对其中的属性进行校验规则的设定。示例如下：

 

  1. public class Girl {

  2.  

  3. private Integer id;

  4.  

  5. @NotBlank(message = "这个字段必传")

  6. private String cupSize;

  7.  

  8. @Min(value = 18, message = "未成年少女禁止入内")

  9. private Integer age;

  10.  

  11. @NotNull(message = "金额必传")

  12. private Double money;

  13.  

  14. ...

  15. }

示例中，"规则注解"的message值可以在Controller中通过bindingResult.getFieldError().getDefaultMessage()获取。

这类用于数据校验的注解还有很多，有兴趣的可以好好研究一下：

注解类型说明
@AssertFalseBoolean,boolean验证注解的元素值是false
@AssertTrueBoolean,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（包含）指定区间之内，如字符长度、集合大小
@Pastjava.util.Date,java.util.Calendar;Joda Time类库的日期类型验证注解的元素值（日期类型）比当前时间早
@Future与@Past要求一样验证注解的元素值（日期类型）比当前时间晚
@NotBlankCharSequence子类型验证注解的元素值不为空（不为null、去除首位空格后长度为0），不同于@NotEmpty，@NotBlank只应用于字符串且在比较时会去除字符串的首位空格
@Length(min=下限, max=上限)CharSequence子类型验证注解的元素值长度在min和max区间内
@NotEmptyCharSequence子类型、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依赖

 

  1. <dependency>

  2. <groupId>org.springframework.boot</groupId>

  3. <artifactId>spring-boot-starter-aop</artifactId>

  4. </dependency>

2）编写切面类

 

  1. @Aspect

  2. @Component

  3. public class HttpAspect {

  4. private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);

  5.  

  6. @Pointcut("execution(public * com.lqr.controller.GirlController.*(..))")

  7. public void log() {

  8. }

  9.  

  10. @Before("log()")

  11. public void deBefore(JoinPoint joinPoint) {

  12. ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

  13. HttpServletRequest request = attributes.getRequest();

  14.  

  15. // url

  16. logger.info("url={}", request.getRequestURL());

  17. // method

  18. logger.info("method={}", request.getMethod());

  19. // ip

  20. logger.info("ip={}", request.getRemoteAddr());

  21. // 类方法

  22. logger.info("class_method={}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());

  23. // 参数

  24. logger.info("args={}", joinPoint.getArgs());

  25.  

  26. }

  27.  

  28. @After("log()")

  29. public void doAfter() {

  30. logger.info("doAfter...");

  31. }

  32.  

  33. @AfterReturning(returning = "object", pointcut = "log()")

  34. public void doAfterReturning(Object object) {

  35. if (object != null)

  36. logger.info("response={}", object.toString());

  37. }

  38.  

  39. }

4、统一异常处理（配置通知Advice）

1）自定义异常

这里之所以继承RuntimeException，是为了方便事务回滚。而自定义异常的好处在于：一方面可以使代码语义化，另一方面使得我们编码更加方便。

 

  1. public class GirlException extends RuntimeException {

  2. private Integer code;

  3.  

  4. public GirlException(ResultEnum resultEnum) {

  5. super(resultEnum.getMsg());

  6. this.code = resultEnum.getCode();

  7. }

  8.  

  9. public Integer getCode() {

  10. return code;

  11. }

  12.  

  13. public void setCode(Integer code) {

  14. this.code = code;

  15. }

  16. }

2）配置全局异常捕获器

使用全局异常捕获器，一方面可以捕获到整个项目中的Exception及其子类（包含RuntimeException等），另一方面可以对异常进行统一处理并返回统一的数据格式，为前端提供友好的数据交互。

 

  1. @ControllerAdvice

  2. public class ExceptionHandle {

  3.  

  4. private final Logger logger = LoggerFactory.getLogger(ExceptionHandle.class);

  5.  

  6. @ExceptionHandler(value = Exception.class)

  7. @ResponseBody

  8. public Result handle(Exception e) {

  9. if (e instanceof GirlException) {

  10. GirlException girlException = (GirlException) e;

  11. return ResultUtils.error(girlException.getCode(), girlException.getMessage());

  12. } else {

  13. logger.error("【系统异常】{}", e);

  14. return ResultUtils.error(-1, "未知错误");

  15. }

  16. }

  17.  

  18. }

三、开发与生产

1、热部署

Web开发中，没有热部署怎么能行呢？所以，下面就介绍下Spring Boot的热部署配置。

1）在pom.xml中配置热部署需要的依赖与插件

 

  1. <dependencies>

  2. ...

  3. <!--spring boot 热部署-->

  4. <dependency>

  5. <groupId>org.springframework.boot</groupId>

  6. <artifactId>spring-boot-devtools</artifactId>

  7. <optional>true</optional>

  8. </dependency>

  9. </dependencies>

  10. <build>

  11. <plugins>

  12. <!--spring boot 热部署-->

  13. <plugin>

  14. <groupId>org.springframework.boot</groupId>

  15. <artifactId>spring-boot-maven-plugin</artifactId>

  16. <configuration>

  17. <fork>true</fork>

  18. </configuration>

  19. </plugin>

  20. </plugins>

  21. ...

  22. </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是不需要用到的。

 

  1. <!--spring boot tomcat（默认可以不用配置，但当需要把当前web应用布置到外部servlet容器时就需要配置，并将scope配置为provided）-->

  2. <dependency>

  3. <groupId>org.springframework.boot</groupId>

  4. <artifactId>spring-boot-starter-tomcat</artifactId>

  5. <scope>provided</scope>

  6. </dependency>

3）修改代码，设置启动配置

需要继承SpringBootServletInitializer，并重写configure()方法，将Spring Boot的入口类设置进去。

 

  1. // 若要部署到外部servlet容器,需要继承SpringBootServletInitializer并重写configure()

  2. @SpringBootApplication

  3. @Configuration

  4. public class MyWebApplication extends SpringBootServletInitializer

  5. {

  6.  

  7. @Override

  8. protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

  9. // 设置启动类,用于独立tomcat运行的入口

  10. return builder.sources(MyWebApplication.class);

  11. }

  12. }

4）打war包并部署到tomcat

 

wrr-cat
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
告诉你，Spring Boot 真是个牛逼货！
weixin_33882452的博客
10-12 1210
现在 Spring Boot 非常火，各种技术文章，各种付费教程，多如牛毛，可能还有些不知道 Spring Boot 的，那它到底是什么呢？有什么用？今天给大家详细介绍一下。 Spring Boot 的背景 了解 Spring Boot 必须先说说 Spring 框架！ 在 Java 后端框架繁荣的今天，Spring 框架无疑是最最火热，也是必不可少的开...
SpringBoot+JPA框架 配置多数据源
weixin_43078114的博客
09-02 1879
【代码】SpringBoot+JPA框架 配置多数据源。
Java web开发--springboot
dengjiayue的博客
07-08 1079
但是有的框架不是很好用:比如Java Servlets(个人感觉)不好调试,WEB-INF文件关联来关联去很烦躁,启动后 crtl+c还关闭不了(我一般习惯用ctrl+c命令来关闭服务).导致后面我调试springboot时一直报错,原来是Java Servlets的服务没关(我习惯性ctrl+c没关掉,也没提示),端口占用的问题。这样就可以探究其他的东西了,例如请求数据的接受处理,数据库连接,rises等等深度探索。直接调试代码,查看环境是否有问题,一般是不会有什么问题的。没使用的方法可以删掉。
SpringBoot 有什么优点？
金木编程
01-27 920
2、快速开发： Spring Boot 提供了一套快速开发的工具和技术，包括内嵌的 Web 服务器（如Tomcat、Jetty、Undertow），自动配置，以及大量的开箱即用的功能。4、自动配置： Spring Boot 根据你的项目的依赖和类路径上的 JAR 包，自动配置应用程序的各个部分，减少了手动配置的需要。当然，你仍然可以覆盖这些自动配置，以满足特定需求。7、大量的社区支持： Spring Boot 是由一个强大的社区支持的开源项目，你可以在社区中找到大量的文档、教程、问题解答和示例代码。
Java Web——SpringBoot
荔枝同学
07-05 164
1. 创建环境 电脑已经安装好IDEA和JDK Spring官网下载包 下载后解压，导入idea File->New->Project from Existing Sources->选择刚才解压的文件，等待下载完成。 2. 开发静态网站 创建index.html页面 启动主程序main 访问：localhost:8080/index.html(未修改端口时) 3. 开发动态网站 ...
走进JavaWeb技术世界（JavaWeb的由来和基础知识+极简配置的SpringBoot+Tomcat5总体架构剖析等）
06-21
走进JavaWeb技术世界（JavaWeb的由来和基础知识+极简配置的SpringBoot+Tomcat5总体架构剖析等+JSP与Servlet的曾经与现在+从JavaBean讲到Spring+Servlet 工作原理详解）
毕业设计: Java项目springboot基于JavaWeb技术的在线考试系统（源码 + 数据库 + 论文）
03-12
2相关技术 2 2.1 MYSQL数据库 3 2.2 B/S结构 3 2.3 Spring Boot框架简介 4 3系统分析 4 3.1可行性分析 4 3.1.1技术可行性 5 3.1.2经济可行性 5 3.1.3操作可行性 5 3.2系统性能分析 5 3.2.1 系统安全性 5 3.2.2 数据...
javaWeb期末考察项目：工资管理系统
01-09
使用框架：SpringBoot，layui 前端：H5+CSS+JS+ajax 后端：servlet+mybatis 数据库：mysql
毕业设计: Java项目springboot基于javaweb的影院订票系统（源码 + 数据库 + 论文）
最新发布
03-24
论文目录： 2 相关技术 3 2.1 SSM框架介绍 3 2.2 B/S结构介绍 3 2.3 Mysql数据库介绍 4 3 系统分析 6 ...5.1.3公告类型管理 16 6 系统测试 17 6.1 系统测试的特点  17 6.2 系统功能测试 18 6.2.1
SpringBoot的优点是什么
weixin_33695082的博客
11-12 318
2019独角兽企业重金招聘Python工程师标准>>> ...
基于JavaWeb、SpringBoot2管理系统
02-24
该系统是开源的管理后台系统，包含了用户管理、组织机构管理、角色管理、功能点管理、菜单管理、权限分配、数据权限分配、代码生成等功能，相比其他开源的后台开发平台脚手架。是一个万能的系统，更是一个值得学习的好系统。
SpringBoot框架的优点
有人想浑水摸鱼，我必须站在清水中
06-14 8932
1、创建独立的Spring应用 2、内嵌web服务器 3、自动starter依赖，简化构建配置 4、自动配置Spring以及第三方功能 5、提供生产级别
SpringBoot优缺点
xh_yj的博客
02-23 1万+
一、SpringBoot优点 1、创建独立Spring应用 2、内嵌web服务器 3、自动starter依赖，简化构建配置 4、自动配置Spring以及第三方功能 5、提供生产级别的监控、健康检查以及外部优化配置 6、无代码生成、无需编写XML 一句话概括：   SpringBoot是整合Spring技术栈的一站式框架   SpringBoot是简化Spring技术栈的快速开发脚手架 二、SpringBoot缺点 1、迭代快 2、封装太深，内部原理复杂，不容易.
SpringBoot的优点
热门推荐
小猛同学的博客
07-21 14万+
一、什么是SpringBoot 在使用传统的Spring去做Java EE（Java Enterprise Edition）开发中，大量的 XML 文件存在于项目之中，导致JavaEE项目变得慢慢笨重起来，，繁琐的配置和整合第三方框架的配置，导致了开发和部署效率的降低。 Spring Boot 并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring ...
【错误解决】SpringBoot启动错误
小鼠标的博客
11-16 6万+
Error starting ApplicationContext. To display the auto-configuration report re-run your application with 'debug' enabled. 2017-11-16 15:32:12.994 ERROR 2668 --- [ main] o.s.b.d.LoggingFailure
YAML书写规范
weixin_38171030的博客
06-26 2226
1. 认识 YAML 　　YAML是一个类似 XML、JSON 的标记性语言。YAML 强调以数据为中心，并不是以标识语言为重点。因而 YAML 本身的定义比较简单，号称“一种人性化的数据格式语言”。 1.1 YAML 的设计目标： 人类容易阅读 可用于不同程序间的数据交换 适合描述程序所使用的数据结构，特别是脚本语言 丰富的表达能力与可扩展性...
java web 整合spring_Spring Boot整合Java web项目
weixin_42489088的博客
02-13 920
Spring Boot简介1：Spring Boot是Spring家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程，也可以说Spring boot能简化我们之前采用SpringMVC+Spring+Mybatis框架进行开发的过程。2：在以往我们采用SpringMVC+Spring+Mybatis框架进行开发的时候，搭建和整合三大框架，我们需要做很好工作，比如配置web.xm...
SpringBoot的第一个程序helloworld
晓梦初醒的博客
01-02 1万+
一开始编写第一个springboot程序helloworld时候,就会觉得不知所措,然后根据网上的一些文档看了一下,真的超级简单.入乡随俗,贴一下优点: Spring Boot的主要优点： 为所有Spring开发者更快的入门开箱即用，提供各种默认配置来简化项目配置内嵌式容器简化Web项目没有冗余代码生成和XML配置的要求 好了,言归正传,我这边使用的时idea, 第一步:创建M
Springboot（二十）启动时数据库初始化spring.datasource/spring.jpa
徐海兴的专栏
08-26 4万+
1.使用springboot jdbc初始化数据库 spring: datasource: username: xuhaixing password: xuhaixing url: jdbc:mysql://192.168.94.151:3306/mytest?useUnicode=true&characterEncoding=utf8&charac...
javaweb:Connection refused: no further information
10-26
"Connection refused: no further information"是指连接被拒绝，但没有更多的信息来解释原因。这通常是由于服务器未响应或未启动导致的。在Java Web应用程序中，这可能是由于以下原因之一引起的： 1. 数据库服务器未启动或未响应。 2. 数据库连接参数不正确。 3. 防火墙或网络配置问题。 4. 应用程序服务器未启动或未响应。 为了解决这个问题，你可以尝试以下步骤： 1. 确保数据库服务器已启动并正在运行。 2. 检查数据库连接参数是否正确。 3. 检查防火墙或网络配置是否允许应用程序服务器连接到数据库服务器。 4. 确保应用程序服务器已启动并正在运行。 如果以上步骤都没有解决问题，你可以尝试使用网络诊断工具来检查网络连接是否正常。如果问题仍然存在，你可以考虑联系系统管理员或技术支持人员以获取更多帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值